From dc4a4ada5822bf90ca271afbbdfb26079eb66d9c Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 1 Sep 2015 12:35:05 -0400 Subject: [PATCH 01/17] move LOCAL_CRATE to cstore --- src/librustc/metadata/cstore.rs | 4 ++++ src/librustc/metadata/decoder.rs | 3 ++- src/librustc/metadata/encoder.rs | 3 ++- src/librustc/middle/astencode.rs | 3 ++- src/librustc/middle/def.rs | 3 ++- src/librustc/middle/def_id.rs | 5 +---- src/librustc/middle/reachable.rs | 3 ++- src/librustc/middle/stability.rs | 3 ++- src/librustc/middle/traits/coherence.rs | 3 ++- src/librustc/middle/traits/select.rs | 3 ++- src/librustc/middle/ty/mod.rs | 3 ++- src/librustc_borrowck/borrowck/fragments.rs | 3 ++- src/librustc_trans/save/mod.rs | 3 ++- src/librustc_trans/trans/base.rs | 3 ++- src/librustc_trans/trans/callee.rs | 3 ++- src/librustc_trans/trans/consts.rs | 3 ++- src/librustc_typeck/astconv.rs | 3 ++- src/librustc_typeck/check/callee.rs | 3 ++- src/librustc_typeck/check/dropck.rs | 3 ++- src/librustc_typeck/check/mod.rs | 3 ++- src/librustc_typeck/coherence/mod.rs | 3 ++- src/librustc_typeck/coherence/orphan.rs | 3 ++- src/librustc_typeck/coherence/overlap.rs | 3 ++- src/librustc_typeck/collect.rs | 3 ++- src/librustc_typeck/variance.rs | 3 ++- src/librustdoc/clean/mod.rs | 3 ++- src/librustdoc/html/format.rs | 3 ++- src/librustdoc/html/render.rs | 1 + 28 files changed, 56 insertions(+), 29 deletions(-) diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 5f60fa8ff40e3..915027041bc44 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -109,6 +109,10 @@ pub struct CStore { pub intr: Rc, } +/// Item definitions in the currently-compiled crate would have the CrateNum +/// LOCAL_CRATE in their DefId. +pub const LOCAL_CRATE: ast::CrateNum = 0; + impl CStore { pub fn new(intr: Rc) -> CStore { CStore { diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 77863ee3c87a2..2e7a49b25fe37 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -20,6 +20,7 @@ use rustc_front::hir; use back::svh::Svh; use metadata::cstore::crate_metadata; +use metadata::cstore::LOCAL_CRATE; use metadata::common::*; use metadata::csearch::MethodInfo; use metadata::csearch; @@ -29,7 +30,7 @@ use metadata::index; use metadata::inline::InlinedItem; use metadata::tydecode::TyDecoder; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::lang_items; use middle::subst; use middle::ty::{ImplContainer, TraitContainer}; diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 0d83103e0bb49..126626e3a208f 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -17,12 +17,13 @@ use back::svh::Svh; use session::config; use metadata::common::*; use metadata::cstore; +use metadata::cstore::LOCAL_CRATE; use metadata::decoder; use metadata::tyencode; use metadata::index::{self, IndexEntry}; use metadata::inline::InlinedItemRef; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::dependency_format::Linkage; use middle::stability; use middle::ty::{self, Ty}; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 270734a21e239..96fb649dd4545 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -19,6 +19,7 @@ use rustc_front::fold::Folder; use metadata::common as c; use metadata::cstore as cstore; +use metadata::cstore::LOCAL_CRATE; use session::Session; use metadata::decoder; use metadata::encoder as e; @@ -31,7 +32,7 @@ use middle::ty::adjustment; use middle::ty::cast; use middle::check_const::ConstQualif; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::privacy::{AllPublic, LastMod}; use middle::region; use middle::subst; diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index 86133aad67216..abd7ed8827546 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -10,7 +10,8 @@ pub use self::Def::*; -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::privacy::LastPrivate; use middle::subst::ParamSpace; use util::nodemap::NodeMap; diff --git a/src/librustc/middle/def_id.rs b/src/librustc/middle/def_id.rs index 2966339f0a4ff..95a593f876f51 100644 --- a/src/librustc/middle/def_id.rs +++ b/src/librustc/middle/def_id.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use metadata::cstore::LOCAL_CRATE; use middle::ty; use syntax::ast::{CrateNum, NodeId}; use std::fmt; @@ -56,7 +57,3 @@ impl DefId { } -/// Item definitions in the currently-compiled crate would have the CrateNum -/// LOCAL_CRATE in their DefId. -pub const LOCAL_CRATE: CrateNum = 0; - diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 017c8f1e42bec..bbf310b65c35d 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -16,8 +16,9 @@ // reachable as well. use front::map as ast_map; +use metadata::cstore::LOCAL_CRATE; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::ty; use middle::privacy; use session::config; diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 596686f32cbc3..b9f5ea863ff4f 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -13,8 +13,9 @@ use session::Session; use lint; +use metadata::cstore::LOCAL_CRATE; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::ty; use middle::privacy::PublicItems; use metadata::csearch; diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 87939c45d67c5..a3795a32afca2 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -17,7 +17,8 @@ use super::PredicateObligation; use super::project; use super::util; -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::subst::{Subst, Substs, TypeSpace}; use middle::ty::{self, ToPolyTraitRef, Ty}; use middle::infer::{self, InferCtxt}; diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 6f422018c13d5..5e12e77435a12 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -37,7 +37,8 @@ use super::{VtableImplData, VtableObjectData, VtableBuiltinData, use super::object_safety; use super::util; -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::infer; use middle::infer::{InferCtxt, TypeFreshener}; use middle::subst::{Subst, Substs, TypeSpace}; diff --git a/src/librustc/middle/ty/mod.rs b/src/librustc/middle/ty/mod.rs index 7ec39619d9cfd..fdec25a82b1ab 100644 --- a/src/librustc/middle/ty/mod.rs +++ b/src/librustc/middle/ty/mod.rs @@ -22,9 +22,10 @@ pub use self::LvaluePreference::*; use front::map as ast_map; use front::map::LinkedPath; use metadata::csearch; +use metadata::cstore::LOCAL_CRATE; use middle; use middle::def::{self, ExportMap}; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem}; use middle::subst::{self, ParamSpace, Subst, Substs, VecPerParamSpace}; use middle::traits; diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index cecbeacadecce..4766fd0cfb720 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -20,7 +20,8 @@ use borrowck::LoanPathKind::{LpVar, LpUpvar, LpDowncast, LpExtend}; use borrowck::LoanPathElem::{LpDeref, LpInterior}; use borrowck::move_data::InvalidMovePathIndex; use borrowck::move_data::{MoveData, MovePathIndex}; -use rustc::middle::def_id::{DefId, LOCAL_CRATE}; +use rustc::metadata::cstore::LOCAL_CRATE; +use rustc::middle::def_id::{DefId}; use rustc::middle::ty; use rustc::middle::mem_categorization as mc; diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index afd16bea6d752..61d8a2191a794 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -8,9 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use metadata::cstore::LOCAL_CRATE; use middle::ty; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use std::env; use std::fs::{self, File}; diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 528b8f9e5324a..8ec2a83ce9040 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -35,9 +35,10 @@ use lint; use llvm::{BasicBlockRef, Linkage, ValueRef, Vector, get_param}; use llvm; use metadata::{csearch, encoder, loader}; +use metadata::cstore::LOCAL_CRATE; use middle::astencode; use middle::cfg; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem}; use middle::weak_lang_items; use middle::pat_util::simple_name; diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index cfa77d57bf619..1704a8010dd8c 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -22,8 +22,9 @@ use arena::TypedArena; use back::link; use session; use llvm::{self, ValueRef, get_params}; +use metadata::cstore::LOCAL_CRATE; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::infer::normalize_associated_type; use middle::subst; use middle::subst::{Substs}; diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 5988f95aedf6c..41d29e0dbd89d 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -13,6 +13,7 @@ use back::abi; use llvm; use llvm::{ConstFCmp, ConstICmp, SetLinkage, SetUnnamedAddr}; use llvm::{InternalLinkage, ValueRef, Bool, True}; +use metadata::cstore::LOCAL_CRATE; use middle::{check_const, def}; use middle::const_eval::{self, ConstVal}; use middle::const_eval::{const_int_checked_neg, const_uint_checked_neg}; @@ -25,7 +26,7 @@ use middle::const_eval::{const_int_checked_shl, const_uint_checked_shl}; use middle::const_eval::{const_int_checked_shr, const_uint_checked_shr}; use middle::const_eval::EvalHint::ExprTypeChecked; use middle::const_eval::eval_const_expr_partial; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use trans::{adt, closure, debuginfo, expr, inline, machine}; use trans::base::{self, push_ctxt}; use trans::common::*; diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 7b2bbbcc4a92a..846ddf2f26a2f 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -48,11 +48,12 @@ //! case but `&a` in the second. Basically, defaults that appear inside //! an rptr (`&r.T`) use the region `r` that appears in the rptr. +use metadata::cstore::LOCAL_CRATE; use middle::astconv_util::{prim_ty_to_ty, prohibit_type_params, prohibit_projection}; use middle::const_eval::{self, ConstVal}; use middle::const_eval::EvalHint::UncheckedExprHint; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::resolve_lifetime as rl; use middle::privacy::{AllPublic, LastMod}; use middle::subst::{FnSpace, TypeSpace, SelfSpace, Subst, Substs, ParamSpace}; diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index 948b7dd156192..dcecec7007d52 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -25,7 +25,8 @@ use super::UnresolvedTypeAction; use super::write_call; use CrateCtxt; -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::infer; use middle::ty::{self, LvaluePreference, Ty}; use syntax::codemap::Span; diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index a8c77f863b700..d847f481142da 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -10,7 +10,8 @@ use check::regionck::{self, Rcx}; -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::free_region::FreeRegionMap; use middle::infer; use middle::region; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index e62f5b82e7a6e..59da69d3696c3 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -83,9 +83,10 @@ use self::TupleArgumentsFlag::*; use astconv::{self, ast_region_to_region, ast_ty_to_ty, AstConv, PathParamMode}; use check::_match::pat_ctxt; use fmt_macros::{Parser, Piece, Position}; +use metadata::cstore::LOCAL_CRATE; use middle::astconv_util::prohibit_type_params; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use middle::infer; use middle::infer::type_variable; use middle::pat_util::{self, pat_id_map}; diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 714bd1d2bc5f3..5c3c95ba4d296 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -16,7 +16,8 @@ // mappings. That mapping code resides here. -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::lang_items::UnsizeTraitLangItem; use middle::subst::{self, Subst}; use middle::traits; diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index 43ae33ac596a0..4f1c958b6ddcd 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -11,7 +11,8 @@ //! Orphan checker: every impl either implements a trait defined in this //! crate or pertains to a type defined in this crate. -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::traits; use middle::ty; use syntax::ast; diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index 55b5f665d11f6..f257dfb62c912 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -11,7 +11,8 @@ //! Overlap: No two impls for the same trait are implemented for the //! same type. -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::traits; use middle::ty; use middle::infer::{self, new_infer_ctxt}; diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index a59e6f54c81d7..2c9f273d703b6 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -65,8 +65,9 @@ There are some shortcomings in this design: */ use astconv::{self, AstConv, ty_of_arg, ast_ty_to_ty, ast_region_to_region}; +use metadata::cstore::LOCAL_CRATE; use middle::def; -use middle::def_id::{DefId, LOCAL_CRATE}; +use middle::def_id::DefId; use constrained_type_params as ctp; use middle::lang_items::SizedTraitLangItem; use middle::free_region::FreeRegionMap; diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 229c52a4e5e5a..4220e258ca5a9 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -266,7 +266,8 @@ use self::ParamKind::*; use arena; use arena::TypedArena; -use middle::def_id::{DefId, LOCAL_CRATE}; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::DefId; use middle::resolve_lifetime as rl; use middle::subst; use middle::subst::{ParamSpace, FnSpace, TypeSpace, SelfSpace, VecPerParamSpace}; diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 89020b011a955..4ecaa46fb4546 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -36,10 +36,11 @@ use syntax::ptr::P; use rustc_trans::back::link; use rustc::metadata::cstore; +use rustc::metadata::cstore::LOCAL_CRATE; use rustc::metadata::csearch; use rustc::metadata::decoder; use rustc::middle::def; -use rustc::middle::def_id::{DefId, LOCAL_CRATE}; +use rustc::middle::def_id::DefId; use rustc::middle::subst::{self, ParamSpace, VecPerParamSpace}; use rustc::middle::ty; use rustc::middle::stability; diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 947ae3abd8d77..f1c3e97a9006c 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -18,7 +18,8 @@ use std::fmt; use std::iter::repeat; -use rustc::middle::def_id::{DefId, LOCAL_CRATE}; +use rustc::metadata::cstore::LOCAL_CRATE; +use rustc::middle::def_id::DefId; use syntax::abi::Abi; use syntax::ast; use rustc_front::hir; diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index b34f1a01a2b0e..509e6c7df7790 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -53,6 +53,7 @@ use externalfiles::ExternalHtml; use serialize::json::{self, ToJson}; use syntax::{abi, ast, attr}; +use rustc::metadata::cstore::LOCAL_CRATE; use rustc::middle::def_id::{DefId, LOCAL_CRATE}; use rustc::util::nodemap::NodeSet; use rustc_front::hir; From 2dd139f5fd51ba8cd2af454c6a36e216708649f2 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 2 Sep 2015 07:09:53 -0400 Subject: [PATCH 02/17] add some XXX markers --- src/librustc/middle/pat_util.rs | 2 +- src/librustc_resolve/record_exports.rs | 2 +- src/librustc_typeck/collect.rs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 0ffa5d7a5e338..ec7274a9b6df2 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -228,7 +228,7 @@ pub fn necessary_variants(dm: &DefMap, pat: &hir::Pat) -> Vec { hir::PatStruct(..) => { match dm.borrow().get(&p.id) { Some(&PathResolution { base_def: DefVariant(_, id, _), .. }) => { - variants.push(id.node); + variants.push(id.node); // XXX } _ => () } diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 36ed2c1457954..076b2fcc004d6 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -102,7 +102,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { self.add_exports_for_module(&mut exports, module_); match module_.def_id.get() { Some(def_id) => { - self.export_map.insert(def_id.node, exports); + self.export_map.insert(def_id.node, exports); // XXX debug!("(computing exports) writing exports for {} (some)", def_id.node); } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 2c9f273d703b6..5811c3c72f789 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -558,7 +558,7 @@ fn is_param<'tcx>(tcx: &ty::ctxt<'tcx>, if let hir::TyPath(None, _) = ast_ty.node { let path_res = *tcx.def_map.borrow().get(&ast_ty.id).unwrap(); match path_res.base_def { - def::DefSelfTy(Some(def_id), None) => { + def::DefSelfTy(Some(def_id), None) => { // XXX path_res.depth == 0 && def_id.node == param_id } def::DefTyParam(_, _, def_id, _) => { From 9ff4f57cd0ee0537b9135a97547daf1131f0bc17 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 2 Sep 2015 16:11:32 -0400 Subject: [PATCH 03/17] move job of creating local-def-ids to ast-map (with a few stragglers) --- src/librustc/front/map/mod.rs | 16 +- src/librustc/metadata/encoder.rs | 71 +++++---- src/librustc/metadata/tydecode.rs | 5 +- src/librustc/metadata/tyencode.rs | 2 +- src/librustc/middle/astencode.rs | 16 +- src/librustc/middle/dead.rs | 4 +- src/librustc/middle/def.rs | 26 ++- src/librustc/middle/def_id.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 4 +- src/librustc/middle/lang_items.rs | 25 +-- src/librustc/middle/stability.rs | 6 +- src/librustc/middle/ty/mod.rs | 27 ++-- src/librustc/middle/ty/sty.rs | 4 +- src/librustc/util/ppaux.rs | 6 +- src/librustc_driver/driver.rs | 2 +- src/librustc_driver/test.rs | 2 +- src/librustc_lint/bad_style.rs | 4 +- src/librustc_lint/builtin.rs | 13 +- src/librustc_mir/dump.rs | 3 +- src/librustc_mir/tcx/expr.rs | 3 +- src/librustc_privacy/lib.rs | 2 +- src/librustc_resolve/build_reduced_graph.rs | 59 ++++--- src/librustc_resolve/lib.rs | 5 +- src/librustc_trans/save/mod.rs | 16 +- src/librustc_trans/trans/base.rs | 3 +- src/librustc_trans/trans/closure.rs | 8 +- src/librustc_trans/trans/common.rs | 3 +- .../trans/debuginfo/metadata.rs | 3 +- src/librustc_trans/trans/debuginfo/mod.rs | 3 +- src/librustc_trans/trans/inline.rs | 9 +- src/librustc_typeck/astconv.rs | 13 +- src/librustc_typeck/check/_match.rs | 6 +- src/librustc_typeck/check/closure.rs | 3 +- src/librustc_typeck/check/intrinsic.rs | 5 +- src/librustc_typeck/check/method/suggest.rs | 10 +- src/librustc_typeck/check/mod.rs | 26 +-- src/librustc_typeck/check/upvar.rs | 9 +- src/librustc_typeck/check/wf.rs | 23 +-- src/librustc_typeck/check/wfcheck.rs | 22 +-- src/librustc_typeck/coherence/mod.rs | 9 +- src/librustc_typeck/coherence/orphan.rs | 2 +- src/librustc_typeck/coherence/overlap.rs | 6 +- src/librustc_typeck/coherence/unsafety.rs | 3 +- src/librustc_typeck/collect.rs | 150 ++++++++++-------- src/librustc_typeck/lib.rs | 10 +- src/librustc_typeck/variance.rs | 14 +- src/librustdoc/clean/mod.rs | 48 +++--- src/librustdoc/core.rs | 9 +- src/librustdoc/html/render.rs | 9 +- src/librustdoc/test.rs | 8 +- src/librustdoc/visit_ast.rs | 3 +- 51 files changed, 414 insertions(+), 326 deletions(-) diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index 16c455537b69a..8d8932552b7d4 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -12,6 +12,7 @@ pub use self::Node::*; pub use self::PathElem::*; use self::MapEntry::*; +use metadata::cstore::LOCAL_CRATE; use metadata::inline::InlinedItem; use metadata::inline::InlinedItem as II; use middle::def_id::DefId; @@ -267,6 +268,18 @@ pub struct Map<'ast> { } impl<'ast> Map<'ast> { + pub fn local_def_id(&self, node: NodeId) -> DefId { + DefId::xxx_local(node) + } + + pub fn as_local_node_id(&self, def_id: DefId) -> Option { + if def_id.krate == LOCAL_CRATE { + Some(def_id.node) + } else { + None + } + } + fn entry_count(&self) -> usize { self.map.borrow().len() } @@ -383,7 +396,7 @@ impl<'ast> Map<'ast> { match self.find_entry(parent) { Some(RootInlinedParent(&InlinedParent {ii: II::TraitItem(did, _), ..})) => did, Some(RootInlinedParent(&InlinedParent {ii: II::ImplItem(did, _), ..})) => did, - _ => DefId::local(parent) + _ => self.local_def_id(parent) } } @@ -1134,3 +1147,4 @@ fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String { } } } + diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 126626e3a208f..b67da4baf5ab0 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -119,7 +119,7 @@ pub fn def_to_string(did: DefId) -> String { fn encode_item_variances(rbml_w: &mut Encoder, ecx: &EncodeContext, id: NodeId) { - let v = ecx.tcx.item_variances(DefId::local(id)); + let v = ecx.tcx.item_variances(ecx.tcx.map.local_def_id(id)); rbml_w.start_tag(tag_item_variances); v.encode(rbml_w); rbml_w.end_tag(); @@ -130,8 +130,8 @@ fn encode_bounds_and_type_for_item<'a, 'tcx>(rbml_w: &mut Encoder, id: NodeId) { encode_bounds_and_type(rbml_w, ecx, - &ecx.tcx.lookup_item_type(DefId::local(id)), - &ecx.tcx.lookup_predicates(DefId::local(id))); + &ecx.tcx.lookup_item_type(ecx.tcx.map.local_def_id(id)), + &ecx.tcx.lookup_predicates(ecx.tcx.map.local_def_id(id))); } fn encode_bounds_and_type<'a, 'tcx>(rbml_w: &mut Encoder, @@ -278,7 +278,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, debug!("encode_enum_variant_info(id={})", id); let mut disr_val = 0; - let def = ecx.tcx.lookup_adt_def(DefId::local(id)); + let def = ecx.tcx.lookup_adt_def(ecx.tcx.map.local_def_id(id)); for variant in &def.variants { let vid = variant.did; assert!(vid.is_local()); @@ -302,7 +302,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, ty::VariantKind::Dict => 'V' }); encode_name(rbml_w, variant.name); - encode_parent_item(rbml_w, DefId::local(id)); + encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(id)); encode_visibility(rbml_w, vis); let attrs = ecx.tcx.get_attrs(vid); @@ -504,7 +504,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, name: Name, vis: hir::Visibility) { rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, DefId::local(id)); + encode_def_id(rbml_w, ecx.tcx.map.local_def_id(id)); encode_family(rbml_w, 'm'); encode_name(rbml_w, name); debug!("(encoding info for module) encoding info for module ID {}", id); @@ -512,11 +512,11 @@ fn encode_info_for_mod(ecx: &EncodeContext, // Encode info about all the module children. for item in &md.items { rbml_w.wr_tagged_u64(tag_mod_child, - def_to_u64(DefId::local(item.id))); + def_to_u64(ecx.tcx.map.local_def_id(item.id))); each_auxiliary_node_id(&**item, |auxiliary_node_id| { rbml_w.wr_tagged_u64(tag_mod_child, - def_to_u64(DefId::local(auxiliary_node_id))); + def_to_u64(ecx.tcx.map.local_def_id(auxiliary_node_id))); true }); @@ -526,14 +526,14 @@ fn encode_info_for_mod(ecx: &EncodeContext, name, did, ecx.tcx.map.node_to_string(did)); - rbml_w.wr_tagged_u64(tag_mod_impl, def_to_u64(DefId::local(did))); + rbml_w.wr_tagged_u64(tag_mod_impl, def_to_u64(ecx.tcx.map.local_def_id(did))); } } encode_path(rbml_w, path.clone()); encode_visibility(rbml_w, vis); - let stab = stability::lookup(ecx.tcx, DefId::local(id)); + let stab = stability::lookup(ecx.tcx, ecx.tcx.map.local_def_id(id)); encode_stability(rbml_w, stab); // Encode the reexports of this module, if this module is public. @@ -627,7 +627,7 @@ fn encode_field<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_struct_field_family(rbml_w, field.vis); encode_name(rbml_w, nm); encode_bounds_and_type_for_item(rbml_w, ecx, id); - encode_def_id(rbml_w, DefId::local(id)); + encode_def_id(rbml_w, ecx.tcx.map.local_def_id(id)); let stab = stability::lookup(ecx.tcx, field.did); encode_stability(rbml_w, stab); @@ -647,18 +647,18 @@ fn encode_info_for_struct_ctor(ecx: &EncodeContext, }); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, DefId::local(ctor_id)); + encode_def_id(rbml_w, ecx.tcx.map.local_def_id(ctor_id)); encode_family(rbml_w, 'o'); encode_bounds_and_type_for_item(rbml_w, ecx, ctor_id); encode_name(rbml_w, name); ecx.tcx.map.with_path(ctor_id, |path| encode_path(rbml_w, path)); - encode_parent_item(rbml_w, DefId::local(struct_id)); + encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(struct_id)); if ecx.item_symbols.borrow().contains_key(&ctor_id) { encode_symbol(ecx, rbml_w, ctor_id); } - let stab = stability::lookup(ecx.tcx, DefId::local(ctor_id)); + let stab = stability::lookup(ecx.tcx, ecx.tcx.map.local_def_id(ctor_id)); encode_stability(rbml_w, stab); // indicate that this is a tuple struct ctor, because downstream users will normally want @@ -789,7 +789,7 @@ fn encode_info_for_associated_const(ecx: &EncodeContext, encode_visibility(rbml_w, associated_const.vis); encode_family(rbml_w, 'C'); - encode_parent_item(rbml_w, DefId::local(parent_id)); + encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(parent_id)); encode_item_sort(rbml_w, 'C'); encode_bounds_and_type_for_item(rbml_w, ecx, associated_const.def_id.local_id()); @@ -802,7 +802,10 @@ fn encode_info_for_associated_const(ecx: &EncodeContext, if let Some(ii) = impl_item_opt { encode_attributes(rbml_w, &ii.attrs); - encode_inlined_item(ecx, rbml_w, InlinedItemRef::ImplItem(DefId::local(parent_id), ii)); + encode_inlined_item(ecx, + rbml_w, + InlinedItemRef::ImplItem(ecx.tcx.map.local_def_id(parent_id), + ii)); } rbml_w.end_tag(); @@ -821,7 +824,7 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, rbml_w.start_tag(tag_items_data_item); encode_method_ty_fields(ecx, rbml_w, m); - encode_parent_item(rbml_w, DefId::local(parent_id)); + encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(parent_id)); encode_item_sort(rbml_w, 'r'); let stab = stability::lookup(ecx.tcx, m.def_id); @@ -840,8 +843,10 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, let needs_inline = any_types || is_default_impl || attr::requests_inline(&impl_item.attrs); if needs_inline || sig.constness == hir::Constness::Const { - encode_inlined_item(ecx, rbml_w, InlinedItemRef::ImplItem(DefId::local(parent_id), - impl_item)); + encode_inlined_item(ecx, + rbml_w, + InlinedItemRef::ImplItem(ecx.tcx.map.local_def_id(parent_id), + impl_item)); } encode_constness(rbml_w, sig.constness); if !any_types { @@ -870,7 +875,7 @@ fn encode_info_for_associated_type<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_name(rbml_w, associated_type.name); encode_visibility(rbml_w, associated_type.vis); encode_family(rbml_w, 'y'); - encode_parent_item(rbml_w, DefId::local(parent_id)); + encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(parent_id)); encode_item_sort(rbml_w, 't'); let stab = stability::lookup(ecx.tcx, associated_type.def_id); @@ -991,8 +996,8 @@ fn encode_info_for_item(ecx: &EncodeContext, debug!("encoding info for item at {}", tcx.sess.codemap().span_to_string(item.span)); - let def_id = DefId::local(item.id); - let stab = stability::lookup(tcx, DefId::local(item.id)); + let def_id = ecx.tcx.map.local_def_id(item.id); + let stab = stability::lookup(tcx, ecx.tcx.map.local_def_id(item.id)); match item.node { hir::ItemStatic(_, m, _) => { @@ -1072,7 +1077,7 @@ fn encode_info_for_item(ecx: &EncodeContext, // Encode all the items in this module. for foreign_item in &fm.items { rbml_w.wr_tagged_u64(tag_mod_child, - def_to_u64(DefId::local(foreign_item.id))); + def_to_u64(ecx.tcx.map.local_def_id(foreign_item.id))); } encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); @@ -1102,7 +1107,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_attributes(rbml_w, &item.attrs); encode_repr_attrs(rbml_w, ecx, &item.attrs); for v in &enum_definition.variants { - encode_variant_id(rbml_w, DefId::local(v.node.id)); + encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.id)); } encode_inlined_item(ecx, rbml_w, InlinedItemRef::Item(item)); encode_path(rbml_w, path); @@ -1174,7 +1179,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_name(rbml_w, item.name); encode_unsafety(rbml_w, unsafety); - let trait_ref = tcx.impl_trait_ref(DefId::local(item.id)).unwrap(); + let trait_ref = tcx.impl_trait_ref(ecx.tcx.map.local_def_id(item.id)).unwrap(); encode_trait_ref(rbml_w, ecx, trait_ref, tag_item_trait_ref); rbml_w.end_tag(); } @@ -1194,7 +1199,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_unsafety(rbml_w, unsafety); encode_polarity(rbml_w, polarity); - match tcx.custom_coerce_unsized_kinds.borrow().get(&DefId::local(item.id)) { + match tcx.custom_coerce_unsized_kinds.borrow().get(&ecx.tcx.map.local_def_id(item.id)) { Some(&kind) => { rbml_w.start_tag(tag_impl_coerce_unsized_kind); kind.encode(rbml_w); @@ -1228,7 +1233,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } rbml_w.end_tag(); } - if let Some(trait_ref) = tcx.impl_trait_ref(DefId::local(item.id)) { + if let Some(trait_ref) = tcx.impl_trait_ref(ecx.tcx.map.local_def_id(item.id)) { encode_trait_ref(rbml_w, ecx, trait_ref, tag_item_trait_ref); } encode_path(rbml_w, path.clone()); @@ -1472,7 +1477,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext, }); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, DefId::local(nitem.id)); + encode_def_id(rbml_w, ecx.tcx.map.local_def_id(nitem.id)); encode_visibility(rbml_w, nitem.vis); match nitem.node { hir::ForeignItemFn(ref fndecl, _) => { @@ -1483,7 +1488,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext, encode_inlined_item(ecx, rbml_w, InlinedItemRef::Foreign(nitem)); } encode_attributes(rbml_w, &*nitem.attrs); - let stab = stability::lookup(ecx.tcx, DefId::local(nitem.id)); + let stab = stability::lookup(ecx.tcx, ecx.tcx.map.local_def_id(nitem.id)); encode_stability(rbml_w, stab); encode_symbol(ecx, rbml_w, nitem.id); encode_method_argument_names(rbml_w, &*fndecl); @@ -1496,7 +1501,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext, } encode_bounds_and_type_for_item(rbml_w, ecx, nitem.id); encode_attributes(rbml_w, &*nitem.attrs); - let stab = stability::lookup(ecx.tcx, DefId::local(nitem.id)); + let stab = stability::lookup(ecx.tcx, ecx.tcx.map.local_def_id(nitem.id)); encode_stability(rbml_w, stab); encode_symbol(ecx, rbml_w, nitem.id); encode_name(rbml_w, nitem.name); @@ -1831,7 +1836,7 @@ impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> { if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() || def_id.krate != LOCAL_CRATE { self.rbml_w.start_tag(tag_impls_impl); - encode_def_id(self.rbml_w, DefId::local(item.id)); + encode_def_id(self.rbml_w, self.ecx.tcx.map.local_def_id(item.id)); self.rbml_w.wr_tagged_u64(tag_impls_impl_trait_def_id, def_to_u64(def_id)); self.rbml_w.end_tag(); } @@ -1873,11 +1878,11 @@ fn encode_misc_info(ecx: &EncodeContext, rbml_w.start_tag(tag_misc_info_crate_items); for item in &krate.module.items { rbml_w.wr_tagged_u64(tag_mod_child, - def_to_u64(DefId::local(item.id))); + def_to_u64(ecx.tcx.map.local_def_id(item.id))); each_auxiliary_node_id(&**item, |auxiliary_node_id| { rbml_w.wr_tagged_u64(tag_mod_child, - def_to_u64(DefId::local(auxiliary_node_id))); + def_to_u64(ecx.tcx.map.local_def_id(auxiliary_node_id))); true }); } diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index abc0429e7d297..75afe11839ce8 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -213,15 +213,14 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { // by the receiver-matching code in collect, which won't // be going down this code path, and anyway I will kill it // the moment wfcheck becomes the standard. - let node_id = self.parse_uint() as ast::NodeId; - assert_eq!(self.next(), '|'); + let def_id = self.parse_def(NominalType); let space = self.parse_param_space(); assert_eq!(self.next(), '|'); let index = self.parse_u32(); assert_eq!(self.next(), '|'); let name = token::intern(&self.parse_str(']')); ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: node_id, + param_id: def_id, space: space, index: index, name: name diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 3176f5c9cc42f..c085f0e582562 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -250,7 +250,7 @@ pub fn enc_region(w: &mut Encoder, cx: &ctxt, r: ty::Region) { } ty::ReEarlyBound(ref data) => { mywrite!(w, "B[{}|{}|{}|{}]", - data.param_id, + (cx.ds)(data.param_id), data.space.to_uint(), data.index, data.name); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 96fb649dd4545..a137d295bd199 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -934,7 +934,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, rbml_w.tag(c::tag_table_upvar_capture_map, |rbml_w| { rbml_w.id(id); - let var_id = freevar.def.def_id().node; + let var_id = freevar.def.node_id(); let upvar_id = ty::UpvarId { var_id: var_id, closure_expr_id: id @@ -997,14 +997,14 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - if let Some(closure_type) = tcx.tables.borrow().closure_tys.get(&DefId::local(id)) { + if let Some(closure_type) = tcx.tables.borrow().closure_tys.get(&tcx.map.local_def_id(id)) { rbml_w.tag(c::tag_table_closure_tys, |rbml_w| { rbml_w.id(id); rbml_w.emit_closure_type(ecx, closure_type); }) } - if let Some(closure_kind) = tcx.tables.borrow().closure_kinds.get(&DefId::local(id)) { + if let Some(closure_kind) = tcx.tables.borrow().closure_kinds.get(&tcx.map.local_def_id(id)) { rbml_w.tag(c::tag_table_closure_kinds, |rbml_w| { rbml_w.id(id); encode_closure_kind(rbml_w, *closure_kind) @@ -1476,14 +1476,16 @@ fn decode_side_tables(dcx: &DecodeContext, c::tag_table_closure_tys => { let closure_ty = val_dsr.read_closure_ty(dcx); - dcx.tcx.tables.borrow_mut().closure_tys.insert(DefId::local(id), - closure_ty); + dcx.tcx.tables.borrow_mut().closure_tys.insert( + dcx.tcx.map.local_def_id(id), + closure_ty); } c::tag_table_closure_kinds => { let closure_kind = val_dsr.read_closure_kind(dcx); - dcx.tcx.tables.borrow_mut().closure_kinds.insert(DefId::local(id), - closure_kind); + dcx.tcx.tables.borrow_mut().closure_kinds.insert( + dcx.tcx.map.local_def_id(id), + closure_kind); } c::tag_table_cast_kinds => { let cast_kind = diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 92592f049e0b1..86dbbb578fff9 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -88,7 +88,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { self.tcx.def_map.borrow().get(id).map(|def| { match def.full_def() { def::DefConst(_) | def::DefAssociatedConst(..) => { - self.check_def_id(def.def_id()) + self.check_def_id(def.def_id()); } _ if self.ignore_non_const_paths => (), def::DefPrimTy(_) => (), @@ -481,7 +481,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { // method of a private type is used, but the type itself is never // called directly. let impl_items = self.tcx.impl_items.borrow(); - match self.tcx.inherent_impls.borrow().get(&DefId::local(id)) { + match self.tcx.inherent_impls.borrow().get(&self.tcx.map.local_def_id(id)) { None => (), Some(impl_list) => { for impl_did in impl_list.iter() { diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index abd7ed8827546..58d747002c927 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -10,7 +10,6 @@ pub use self::Def::*; -use metadata::cstore::LOCAL_CRATE; use middle::def_id::DefId; use middle::privacy::LastPrivate; use middle::subst::ParamSpace; @@ -115,10 +114,24 @@ pub struct Export { } impl Def { - pub fn local_node_id(&self) -> ast::NodeId { - let def_id = self.def_id(); - assert_eq!(def_id.krate, LOCAL_CRATE); - def_id.node + pub fn node_id(&self) -> ast::NodeId { + match *self { + DefLocal(id) | + DefUpvar(id, _, _) | + DefRegion(id) | + DefLabel(id) | + DefSelfTy(_, Some((_, id))) => { + id + } + + DefFn(_, _) | DefMod(_) | DefForeignMod(_) | DefStatic(_, _) | + DefVariant(_, _, _) | DefTy(_, _) | DefAssociatedTy(_, _) | + DefTyParam(_, _, _, _) | DefUse(_) | DefStruct(_) | DefTrait(_) | + DefMethod(_) | DefConst(_) | DefAssociatedConst(_) | + DefSelfTy(Some(_), None) | DefPrimTy(_) | DefSelfTy(..) => { + panic!("attempted .def_id() on invalid {:?}", self) + } + } } pub fn def_id(&self) -> DefId { @@ -130,12 +143,13 @@ impl Def { DefSelfTy(Some(id), None)=> { id } + DefLocal(id) | DefUpvar(id, _, _) | DefRegion(id) | DefLabel(id) | DefSelfTy(_, Some((_, id))) => { - DefId::local(id) + DefId::xxx_local(id) // TODO, clearly } DefPrimTy(_) => panic!("attempted .def_id() on DefPrimTy"), diff --git a/src/librustc/middle/def_id.rs b/src/librustc/middle/def_id.rs index 95a593f876f51..bbfaffb111266 100644 --- a/src/librustc/middle/def_id.rs +++ b/src/librustc/middle/def_id.rs @@ -41,7 +41,7 @@ impl fmt::Debug for DefId { impl DefId { - pub fn local(id: NodeId) -> DefId { + pub fn xxx_local(id: NodeId) -> DefId { DefId { krate: LOCAL_CRATE, node: id } } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 13e8fddf77912..86b321a94550c 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -1160,7 +1160,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { self.tcx().with_freevars(closure_expr.id, |freevars| { for freevar in freevars { - let id_var = freevar.def.def_id().node; + let id_var = freevar.def.node_id(); let upvar_id = ty::UpvarId { var_id: id_var, closure_expr_id: closure_expr.id }; let upvar_capture = self.typer.upvar_capture(upvar_id).unwrap(); @@ -1192,7 +1192,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { -> mc::McResult> { // Create the cmt for the variable being borrowed, from the // caller's perspective - let var_id = upvar_def.def_id().node; + let var_id = upvar_def.node_id(); let var_ty = try!(self.typer.node_ty(var_id)); self.mc.cat_def(closure_id, closure_span, var_ty, upvar_def) } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 85e51512bca31..262c5c1422b7c 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -21,6 +21,7 @@ pub use self::LangItem::*; +use front::map as hir_map; use session::Session; use metadata::csearch::each_lang_item; use middle::def_id::DefId; @@ -144,21 +145,23 @@ impl LanguageItems { )* } -struct LanguageItemCollector<'a> { +struct LanguageItemCollector<'a, 'tcx: 'a> { items: LanguageItems, + ast_map: &'a hir_map::Map<'tcx>, + session: &'a Session, item_refs: FnvHashMap<&'static str, usize>, } -impl<'a, 'v> Visitor<'v> for LanguageItemCollector<'a> { +impl<'a, 'v, 'tcx> Visitor<'v> for LanguageItemCollector<'a, 'tcx> { fn visit_item(&mut self, item: &hir::Item) { if let Some(value) = extract(&item.attrs) { let item_index = self.item_refs.get(&value[..]).cloned(); if let Some(item_index) = item_index { - self.collect_item(item_index, DefId::local(item.id), item.span) + self.collect_item(item_index, self.ast_map.local_def_id(item.id), item.span) } } @@ -166,16 +169,18 @@ impl<'a, 'v> Visitor<'v> for LanguageItemCollector<'a> { } } -impl<'a> LanguageItemCollector<'a> { - pub fn new(session: &'a Session) -> LanguageItemCollector<'a> { +impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { + pub fn new(session: &'a Session, ast_map: &'a hir_map::Map<'tcx>) + -> LanguageItemCollector<'a, 'tcx> { let mut item_refs = FnvHashMap(); $( item_refs.insert($name, $variant as usize); )* LanguageItemCollector { session: session, + ast_map: ast_map, items: LanguageItems::new(), - item_refs: item_refs + item_refs: item_refs, } } @@ -230,9 +235,11 @@ pub fn extract(attrs: &[ast::Attribute]) -> Option { return None; } -pub fn collect_language_items(krate: &hir::Crate, - session: &Session) -> LanguageItems { - let mut collector = LanguageItemCollector::new(session); +pub fn collect_language_items(session: &Session, + map: &hir_map::Map) + -> LanguageItems { + let krate: &hir::Crate = map.krate(); + let mut collector = LanguageItemCollector::new(session, map); collector.collect(krate); let LanguageItemCollector { mut items, .. } = collector; weak_lang_items::check_crate(krate, session, &mut items); diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index b9f5ea863ff4f..b6a4c97b180bf 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -113,7 +113,8 @@ impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> { "An API can't be stabilized after it is deprecated"); } - self.index.map.insert(DefId::local(id), Some(stab)); + let def_id = self.tcx.map.local_def_id(id); + self.index.map.insert(def_id, Some(stab)); // Don't inherit #[stable(feature = "rust1", since = "1.0.0")] if stab.level != attr::Stable { @@ -129,7 +130,8 @@ impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> { use_parent, self.parent); if use_parent { if let Some(stab) = self.parent { - self.index.map.insert(DefId::local(id), Some(stab)); + let def_id = self.tcx.map.local_def_id(id); + self.index.map.insert(def_id, Some(stab)); } else if self.index.staged_api[&LOCAL_CRATE] && required && self.export_map.contains(&id) && !self.tcx.sess.opts.test { diff --git a/src/librustc/middle/ty/mod.rs b/src/librustc/middle/ty/mod.rs index fdec25a82b1ab..a48d34281bb63 100644 --- a/src/librustc/middle/ty/mod.rs +++ b/src/librustc/middle/ty/mod.rs @@ -618,7 +618,7 @@ pub struct RegionParameterDef { impl RegionParameterDef { pub fn to_early_bound_region(&self) -> ty::Region { ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: self.def_id.node, + param_id: self.def_id, space: self.space, index: self.index, name: self.name, @@ -1125,7 +1125,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { // associated types don't have their own entry (for some reason), // so for now just grab environment for the impl let impl_id = cx.map.get_parent(id); - let impl_def_id = DefId::local(impl_id); + let impl_def_id = cx.map.local_def_id(impl_id); let scheme = cx.lookup_item_type(impl_def_id); let predicates = cx.lookup_predicates(impl_def_id); cx.construct_parameter_environment(impl_item.span, @@ -1134,7 +1134,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { id) } hir::ConstImplItem(_, _) => { - let def_id = DefId::local(id); + let def_id = cx.map.local_def_id(id); let scheme = cx.lookup_item_type(def_id); let predicates = cx.lookup_predicates(def_id); cx.construct_parameter_environment(impl_item.span, @@ -1143,7 +1143,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { id) } hir::MethodImplItem(_, ref body) => { - let method_def_id = DefId::local(id); + let method_def_id = cx.map.local_def_id(id); match cx.impl_or_trait_item(method_def_id) { MethodTraitItem(ref method_ty) => { let method_generics = &method_ty.generics; @@ -1169,7 +1169,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { // associated types don't have their own entry (for some reason), // so for now just grab environment for the trait let trait_id = cx.map.get_parent(id); - let trait_def_id = DefId::local(trait_id); + let trait_def_id = cx.map.local_def_id(trait_id); let trait_def = cx.lookup_trait_def(trait_def_id); let predicates = cx.lookup_predicates(trait_def_id); cx.construct_parameter_environment(trait_item.span, @@ -1178,7 +1178,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { id) } hir::ConstTraitItem(..) => { - let def_id = DefId::local(id); + let def_id = cx.map.local_def_id(id); let scheme = cx.lookup_item_type(def_id); let predicates = cx.lookup_predicates(def_id); cx.construct_parameter_environment(trait_item.span, @@ -1191,8 +1191,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { // block, unless this is a trait method with // no default, then fallback to the method id. let body_id = body.as_ref().map(|b| b.id).unwrap_or(id); - let method_def_id = DefId::local(id); - + let method_def_id = cx.map.local_def_id(id); match cx.impl_or_trait_item(method_def_id) { MethodTraitItem(ref method_ty) => { let method_generics = &method_ty.generics; @@ -1217,7 +1216,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { match item.node { hir::ItemFn(_, _, _, _, _, ref body) => { // We assume this is a function. - let fn_def_id = DefId::local(id); + let fn_def_id = cx.map.local_def_id(id); let fn_scheme = cx.lookup_item_type(fn_def_id); let fn_predicates = cx.lookup_predicates(fn_def_id); @@ -1231,7 +1230,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { hir::ItemImpl(..) | hir::ItemConst(..) | hir::ItemStatic(..) => { - let def_id = DefId::local(id); + let def_id = cx.map.local_def_id(id); let scheme = cx.lookup_item_type(def_id); let predicates = cx.lookup_predicates(def_id); cx.construct_parameter_environment(item.span, @@ -1240,7 +1239,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { id) } hir::ItemTrait(..) => { - let def_id = DefId::local(id); + let def_id = cx.map.local_def_id(id); let trait_def = cx.lookup_trait_def(def_id); let predicates = cx.lookup_predicates(def_id); cx.construct_parameter_environment(item.span, @@ -2106,7 +2105,7 @@ impl<'tcx> ctxt<'tcx> { if let ItemTrait(_, _, _, ref ms) = self.map.expect_item(id.node).node { ms.iter().filter_map(|ti| { if let hir::MethodTraitItem(_, Some(_)) = ti.node { - match self.impl_or_trait_item(DefId::local(ti.id)) { + match self.impl_or_trait_item(self.map.local_def_id(ti.id)) { MethodTraitItem(m) => Some(m), _ => { self.sess.bug("provided_trait_methods(): \ @@ -2132,7 +2131,7 @@ impl<'tcx> ctxt<'tcx> { ItemTrait(_, _, _, ref tis) => { tis.iter().filter_map(|ti| { if let hir::ConstTraitItem(_, _) = ti.node { - match self.impl_or_trait_item(DefId::local(ti.id)) { + match self.impl_or_trait_item(self.map.local_def_id(ti.id)) { ConstTraitItem(ac) => Some(ac), _ => { self.sess.bug("associated_consts(): \ @@ -2148,7 +2147,7 @@ impl<'tcx> ctxt<'tcx> { ItemImpl(_, _, _, _, _, ref iis) => { iis.iter().filter_map(|ii| { if let hir::ConstImplItem(_, _) = ii.node { - match self.impl_or_trait_item(DefId::local(ii.id)) { + match self.impl_or_trait_item(self.map.local_def_id(ii.id)) { ConstTraitItem(ac) => Some(ac), _ => { self.sess.bug("associated_consts(): \ diff --git a/src/librustc/middle/ty/sty.rs b/src/librustc/middle/ty/sty.rs index 44f97a6b9e3c3..c553e3ca5b38d 100644 --- a/src/librustc/middle/ty/sty.rs +++ b/src/librustc/middle/ty/sty.rs @@ -23,7 +23,7 @@ use std::fmt; use std::ops; use std::mem; use syntax::abi; -use syntax::ast::{self, Name, NodeId}; +use syntax::ast::{self, Name}; use syntax::parse::token::special_idents; use rustc_front::hir; @@ -675,7 +675,7 @@ pub enum Region { #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)] pub struct EarlyBoundRegion { - pub param_id: NodeId, + pub param_id: DefId, pub space: subst::ParamSpace, pub index: u32, pub name: Name, diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 68bfa42f6f6cb..8daaf1325eae7 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -232,7 +232,7 @@ fn in_binder<'tcx, T, U>(f: &mut fmt::Formatter, ty::BrEnv => { let name = token::intern("'r"); let _ = write!(f, "{}", name); - ty::BrNamed(DefId::local(DUMMY_NODE_ID), name) + ty::BrNamed(tcx.map.local_def_id(DUMMY_NODE_ID), name) } }) }).0; @@ -466,7 +466,7 @@ impl fmt::Debug for ty::Region { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { ty::ReEarlyBound(ref data) => { - write!(f, "ReEarlyBound({}, {:?}, {}, {})", + write!(f, "ReEarlyBound({:?}, {:?}, {}, {})", data.param_id, data.space, data.index, @@ -896,7 +896,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> { let mut sep = " "; try!(tcx.with_freevars(did.node, |freevars| { for (freevar, upvar_ty) in freevars.iter().zip(&substs.upvar_tys) { - let node_id = freevar.def.local_node_id(); + let node_id = freevar.def.node_id(); try!(write!(f, "{}{}:{}", sep, diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index ce04a5befd939..d004d557856b7 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -661,7 +661,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: Session, LocalCrateReader::new(&sess, &ast_map).read_crates(krate)); let lang_items = time(time_passes, "language item collection", || - middle::lang_items::collect_language_items(krate, &sess)); + middle::lang_items::collect_language_items(&sess, &ast_map)); let resolve::CrateMap { def_map, diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index cf98b1bd8fda2..4b3b3a5e84827 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -130,7 +130,7 @@ fn test_env(source_string: &str, let krate = ast_map.krate(); // run just enough stuff to build a tcx: - let lang_items = lang_items::collect_language_items(krate, &sess); + let lang_items = lang_items::collect_language_items(&sess, &ast_map); let resolve::CrateMap { def_map, freevars, .. } = resolve::resolve_crate(&sess, &ast_map, resolve::MakeGlobMap::No); let named_region_map = resolve_lifetime::krate(&sess, krate, &def_map); diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 51b2d58a58139..afa736d2220d3 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -9,7 +9,6 @@ // except according to those terms. use middle::def; -use middle::def_id::DefId; use middle::ty; use lint::{LateContext, LintContext, LintArray}; use lint::{LintPass, LateLintPass}; @@ -29,7 +28,8 @@ pub enum MethodLateContext { } pub fn method_context(cx: &LateContext, id: ast::NodeId, span: Span) -> MethodLateContext { - match cx.tcx.impl_or_trait_items.borrow().get(&DefId::local(id)) { + let def_id = cx.tcx.map.local_def_id(id); + match cx.tcx.impl_or_trait_items.borrow().get(&def_id) { None => cx.sess().span_bug(span, "missing method descriptor?!"), Some(item) => match item.container() { ty::TraitContainer(..) => MethodLateContext::TraitDefaultImpl, diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 90f877b29a134..9d502a312616a 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -555,7 +555,7 @@ impl LateLintPass for MissingCopyImplementations { if ast_generics.is_parameterized() { return; } - let def = cx.tcx.lookup_adt_def(DefId::local(item.id)); + let def = cx.tcx.lookup_adt_def(cx.tcx.map.local_def_id(item.id)); (def, cx.tcx.mk_struct(def, cx.tcx.mk_substs(Substs::empty()))) } @@ -563,7 +563,7 @@ impl LateLintPass for MissingCopyImplementations { if ast_generics.is_parameterized() { return; } - let def = cx.tcx.lookup_adt_def(DefId::local(item.id)); + let def = cx.tcx.lookup_adt_def(cx.tcx.map.local_def_id(item.id)); (def, cx.tcx.mk_enum(def, cx.tcx.mk_substs(Substs::empty()))) } @@ -764,7 +764,7 @@ impl LateLintPass for UnconditionalRecursion { let method = match fn_kind { FnKind::ItemFn(..) => None, FnKind::Method(..) => { - cx.tcx.impl_or_trait_item(DefId::local(id)).as_opt_method() + cx.tcx.impl_or_trait_item(cx.tcx.map.local_def_id(id)).as_opt_method() } // closures can't recur, so they don't matter. FnKind::Closure => return @@ -877,8 +877,11 @@ impl LateLintPass for UnconditionalRecursion { id: ast::NodeId) -> bool { match tcx.map.get(id) { hir_map::NodeExpr(&hir::Expr { node: hir::ExprCall(ref callee, _), .. }) => { - tcx.def_map.borrow().get(&callee.id) - .map_or(false, |def| def.def_id() == DefId::local(fn_id)) + tcx.def_map + .borrow() + .get(&callee.id) + .map_or(false, + |def| def.def_id() == tcx.map.local_def_id(fn_id)) } _ => false } diff --git a/src/librustc_mir/dump.rs b/src/librustc_mir/dump.rs index 9b3514028afad..ebde7e1d097b3 100644 --- a/src/librustc_mir/dump.rs +++ b/src/librustc_mir/dump.rs @@ -26,7 +26,6 @@ use repr::Mir; use std::fs::File; use tcx::{PatNode, Cx}; -use self::rustc::middle::def_id::DefId; use self::rustc::middle::infer; use self::rustc::middle::region::CodeExtentData; use self::rustc::middle::ty::{self, Ty}; @@ -210,7 +209,7 @@ fn closure_self_ty<'a,'tcx>(tcx: &ty::ctxt<'tcx>, let region = tcx.mk_region(region); - match tcx.closure_kind(DefId::local(closure_expr_id)) { + match tcx.closure_kind(tcx.map.local_def_id(closure_expr_id)) { ty::ClosureKind::FnClosureKind => tcx.mk_ref(region, ty::TypeAndMut { ty: closure_ty, diff --git a/src/librustc_mir/tcx/expr.rs b/src/librustc_mir/tcx/expr.rs index 6c9713b003b64..6560f8449c426 100644 --- a/src/librustc_mir/tcx/expr.rs +++ b/src/librustc_mir/tcx/expr.rs @@ -17,7 +17,6 @@ use tcx::block; use tcx::pattern::PatNode; use tcx::rustc::front::map; use tcx::rustc::middle::def; -use tcx::rustc::middle::def_id::DefId; use tcx::rustc::middle::region::CodeExtent; use tcx::rustc::middle::pat_util; use tcx::rustc::middle::ty::{self, Ty}; @@ -612,7 +611,7 @@ fn convert_var<'a,'tcx:'a>(cx: &mut Cx<'a,'tcx>, let region = cx.tcx.mk_region(region); - let self_expr = match cx.tcx.closure_kind(DefId::local(closure_expr_id)) { + let self_expr = match cx.tcx.closure_kind(cx.tcx.map.local_def_id(closure_expr_id)) { ty::ClosureKind::FnClosureKind => { let ref_closure_ty = cx.tcx.mk_ref(region, diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 2090527ca202d..aa41dccc6dcd7 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -272,7 +272,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { } _ => true, }; - let tr = self.tcx.impl_trait_ref(DefId::local(item.id)); + let tr = self.tcx.impl_trait_ref(self.tcx.map.local_def_id(item.id)); let public_trait = tr.clone().map_or(false, |tr| { !tr.def_id.is_local() || self.exported_items.contains(&tr.def_id.node) diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 8a15eabd61419..1f850fc9687c1 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -427,18 +427,20 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let name_bindings = self.add_child(name, parent, ForbidDuplicateValues, sp); let mutbl = m == hir::MutMutable; - name_bindings.define_value(DefStatic(DefId::local(item.id), mutbl), sp, modifiers); + name_bindings.define_value(DefStatic(self.ast_map.local_def_id(item.id), mutbl), + sp, + modifiers); parent.clone() } ItemConst(_, _) => { self.add_child(name, parent, ForbidDuplicateValues, sp) - .define_value(DefConst(DefId::local(item.id)), sp, modifiers); + .define_value(DefConst(self.ast_map.local_def_id(item.id)), sp, modifiers); parent.clone() } ItemFn(_, _, _, _, _, _) => { let name_bindings = self.add_child(name, parent, ForbidDuplicateValues, sp); - let def = DefFn(DefId::local(item.id), false); + let def = DefFn(self.ast_map.local_def_id(item.id), false); name_bindings.define_value(def, sp, modifiers); parent.clone() } @@ -448,12 +450,12 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let name_bindings = self.add_child(name, parent, ForbidDuplicateTypesAndModules, sp); - name_bindings.define_type(DefTy(DefId::local(item.id), false), sp, + name_bindings.define_type(DefTy(self.ast_map.local_def_id(item.id), false), sp, modifiers); let parent_link = self.get_parent_link(parent, name); name_bindings.set_module_kind(parent_link, - Some(DefId::local(item.id)), + Some(self.ast_map.local_def_id(item.id)), TypeModuleKind, false, is_public, @@ -465,11 +467,13 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let name_bindings = self.add_child(name, parent, ForbidDuplicateTypesAndModules, sp); - name_bindings.define_type(DefTy(DefId::local(item.id), true), sp, modifiers); + name_bindings.define_type(DefTy(self.ast_map.local_def_id(item.id), true), + sp, + modifiers); let parent_link = self.get_parent_link(parent, name); name_bindings.set_module_kind(parent_link, - Some(DefId::local(item.id)), + Some(self.ast_map.local_def_id(item.id)), EnumModuleKind, false, is_public, @@ -478,9 +482,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let module = name_bindings.get_module(); for variant in &(*enum_definition).variants { + let item_def_id = self.ast_map.local_def_id(item.id); self.build_reduced_graph_for_variant( &**variant, - DefId::local(item.id), + item_def_id, &module); } parent.clone() @@ -497,12 +502,16 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let name_bindings = self.add_child(name, parent, forbid, sp); // Define a name in the type namespace. - name_bindings.define_type(DefTy(DefId::local(item.id), false), sp, modifiers); + name_bindings.define_type(DefTy(self.ast_map.local_def_id(item.id), false), + sp, + modifiers); // If this is a newtype or unit-like struct, define a name // in the value namespace as well if let Some(cid) = ctor_id { - name_bindings.define_value(DefStruct(DefId::local(cid)), sp, modifiers); + name_bindings.define_value(DefStruct(self.ast_map.local_def_id(cid)), + sp, + modifiers); } // Record the def ID and fields of this struct. @@ -512,7 +521,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { UnnamedField(_) => None } }).collect(); - self.structs.insert(DefId::local(item.id), named_fields); + let item_def_id = self.ast_map.local_def_id(item.id); + self.structs.insert(item_def_id, named_fields); parent.clone() } @@ -527,14 +537,14 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // Add all the items within to a new module. let parent_link = self.get_parent_link(parent, name); name_bindings.define_module(parent_link, - Some(DefId::local(item.id)), + Some(self.ast_map.local_def_id(item.id)), TraitModuleKind, false, is_public, sp); let module_parent = name_bindings.get_module(); - let def_id = DefId::local(item.id); + let def_id = self.ast_map.local_def_id(item.id); // Add the names of all the items to the trait info. for trait_item in items { @@ -545,25 +555,25 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { match trait_item.node { hir::ConstTraitItem(..) => { - let def = DefAssociatedConst(DefId::local(trait_item.id)); + let def = DefAssociatedConst(self.ast_map.local_def_id(trait_item.id)); // NB: not DefModifiers::IMPORTABLE name_bindings.define_value(def, trait_item.span, DefModifiers::PUBLIC); } hir::MethodTraitItem(..) => { - let def = DefMethod(DefId::local(trait_item.id)); + let def = DefMethod(self.ast_map.local_def_id(trait_item.id)); // NB: not DefModifiers::IMPORTABLE name_bindings.define_value(def, trait_item.span, DefModifiers::PUBLIC); } hir::TypeTraitItem(..) => { - let def = DefAssociatedTy(DefId::local(item.id), - DefId::local(trait_item.id)); + let def = DefAssociatedTy(self.ast_map.local_def_id(item.id), + self.ast_map.local_def_id(trait_item.id)); // NB: not DefModifiers::IMPORTABLE name_bindings.define_type(def, trait_item.span, DefModifiers::PUBLIC); } } - self.trait_item_map.insert((trait_item.name, def_id), - DefId::local(trait_item.id)); + let trait_item_def_id = self.ast_map.local_def_id(trait_item.id); + self.trait_item_map.insert((trait_item.name, def_id), trait_item_def_id); } name_bindings.define_type(DefTrait(def_id), sp, modifiers); @@ -583,7 +593,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { TupleVariantKind(_) => false, StructVariantKind(_) => { // Not adding fields for variants as they are not accessed with a self receiver - self.structs.insert(DefId::local(variant.node.id), Vec::new()); + let variant_def_id = self.ast_map.local_def_id(variant.node.id); + self.structs.insert(variant_def_id, Vec::new()); true } }; @@ -594,10 +605,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // variants are always treated as importable to allow them to be glob // used child.define_value(DefVariant(item_id, - DefId::local(variant.node.id), is_exported), + self.ast_map.local_def_id(variant.node.id), is_exported), variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); child.define_type(DefVariant(item_id, - DefId::local(variant.node.id), is_exported), + self.ast_map.local_def_id(variant.node.id), is_exported), variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE); } @@ -618,10 +629,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let def = match foreign_item.node { ForeignItemFn(..) => { - DefFn(DefId::local(foreign_item.id), false) + DefFn(self.ast_map.local_def_id(foreign_item.id), false) } ForeignItemStatic(_, m) => { - DefStatic(DefId::local(foreign_item.id), m) + DefStatic(self.ast_map.local_def_id(foreign_item.id), m) } }; name_bindings.define_value(def, foreign_item.span, modifiers); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 4f6b3f9353afa..4497bfb3898d3 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -2156,7 +2156,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { TypeSpace, ItemRibKind), |this| { - this.with_self_rib(DefSelfTy(Some(DefId::local(item.id)), None), |this| { + let local_def_id = this.ast_map.local_def_id(item.id); + this.with_self_rib(DefSelfTy(Some(local_def_id), None), |this| { this.visit_generics(generics); walk_list!(this, visit_ty_param_bound, bounds); @@ -2280,7 +2281,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { function_type_rib.bindings.insert(name, DlDef(DefTyParam(space, index as u32, - DefId::local(type_parameter.id), + self.ast_map.local_def_id(type_parameter.id), name))); } self.type_ribs.push(function_type_rib); diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 61d8a2191a794..c2ec4456e118a 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -349,7 +349,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { pub fn get_method_data(&self, id: ast::NodeId, name: ast::Name, span: Span) -> FunctionData { // The qualname for a method is the trait name or name of the struct in an impl in // which the method is declared in, followed by the method's name. - let qualname = match self.tcx.impl_of_method(DefId::local(id)) { + let qualname = match self.tcx.impl_of_method(self.tcx.map.local_def_id(id)) { Some(impl_id) => match self.tcx.map.get(impl_id.node) { NodeItem(item) => { match item.node { @@ -357,7 +357,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { let mut result = String::from("<"); result.push_str(&rustc_front::print::pprust::ty_to_string(&**ty)); - match self.tcx.trait_of_item(DefId::local(id)) { + match self.tcx.trait_of_item(self.tcx.map.local_def_id(id)) { Some(def_id) => { result.push_str(" as "); result.push_str( @@ -381,7 +381,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { impl_id.node, id, self.tcx.map.get(impl_id.node))); } }, - None => match self.tcx.trait_of_item(DefId::local(id)) { + None => match self.tcx.trait_of_item(self.tcx.map.local_def_id(id)) { Some(def_id) => { match self.tcx.map.get(def_id.node) { NodeItem(_) => { @@ -403,11 +403,13 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { let qualname = format!("{}::{}", qualname, name); - let decl_id = self.tcx.trait_item_of_item(DefId::local(id)) + let def_id = self.tcx.map.local_def_id(id); + let decl_id = + self.tcx.trait_item_of_item(def_id) .and_then(|new_id| { - let def_id = new_id.def_id(); - if def_id.node != 0 && def_id != DefId::local(id) { - Some(def_id) + let new_def_id = new_id.def_id(); + if new_def_id.node != 0 && new_def_id != def_id { + Some(new_def_id) } else { None } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 8ec2a83ce9040..8a0578332e6be 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -2086,7 +2086,8 @@ pub fn trans_item(ccx: &CrateContext, item: &hir::Item) { // error in trans. This is used to write compile-fail tests // that actually test that compilation succeeds without // reporting an error. - if ccx.tcx().has_attr(DefId::local(item.id), "rustc_error") { + let item_def_id = ccx.tcx().map.local_def_id(item.id); + if ccx.tcx().has_attr(item_def_id, "rustc_error") { ccx.tcx().sess.span_fatal(item.span, "compilation successful"); } } diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index dc9ea62e9d11a..d992f6eeab19e 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -43,7 +43,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("closure::load_closure_environment"); // Special case for small by-value selfs. - let closure_id = DefId::local(bcx.fcx.id); + let closure_id = bcx.tcx().map.local_def_id(bcx.fcx.id); let self_type = self_type_for_closure(bcx.ccx(), closure_id, node_id_type(bcx, closure_id.node)); let kind = kind_for_closure(bcx.ccx(), closure_id); @@ -69,7 +69,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }; for (i, freevar) in freevars.iter().enumerate() { - let upvar_id = ty::UpvarId { var_id: freevar.def.local_node_id(), + let upvar_id = ty::UpvarId { var_id: freevar.def.node_id(), closure_expr_id: closure_id.node }; let upvar_capture = bcx.tcx().upvar_capture(upvar_id).unwrap(); let mut upvar_ptr = StructGEP(bcx, llenv, i); @@ -190,7 +190,7 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, debug!("trans_closure_expr()"); - let closure_id = DefId::local(id); + let closure_id = tcx.map.local_def_id(id); let llfn = get_or_create_closure_declaration(ccx, closure_id, closure_substs); // Get the type of this closure. Use the current `param_substs` as @@ -235,7 +235,7 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, for (i, freevar) in freevars.iter().enumerate() { let datum = expr::trans_local_var(bcx, freevar.def); let upvar_slot_dest = adt::trans_field_ptr(bcx, &*repr, dest_addr, 0, i); - let upvar_id = ty::UpvarId { var_id: freevar.def.local_node_id(), + let upvar_id = ty::UpvarId { var_id: freevar.def.node_id(), closure_expr_id: id }; match tcx.upvar_capture(upvar_id).unwrap() { ty::UpvarCapture::ByValue => { diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 78f631371c093..ba50bec2ecd91 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -1145,8 +1145,9 @@ pub fn inlined_variant_def<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, }), ..}) => ty, _ => ctor_ty }.ty_adt_def().unwrap(); + let inlined_vid_def_id = ccx.tcx().map.local_def_id(inlined_vid); adt_def.variants.iter().find(|v| { - DefId::local(inlined_vid) == v.did || + inlined_vid_def_id == v.did || ccx.external().borrow().get(&v.did) == Some(&Some(inlined_vid)) }).unwrap_or_else(|| { ccx.sess().bug(&format!("no variant for {:?}::{}", adt_def, inlined_vid)) diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 1d35b51a5f81c..75dc67bd9b09b 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -1887,7 +1887,8 @@ pub fn create_global_var_metadata(cx: &CrateContext, let is_local_to_unit = is_node_local_to_unit(cx, node_id); let variable_type = cx.tcx().node_id_to_type(node_id); let type_metadata = type_metadata(cx, variable_type, span); - let namespace_node = namespace_for_item(cx, DefId::local(node_id)); + let node_def_id = cx.tcx().map.local_def_id(node_id); + let namespace_node = namespace_for_item(cx, node_def_id); let var_name = name.to_string(); let linkage_name = namespace_node.mangled_name_of_contained_item(&var_name[..]); diff --git a/src/librustc_trans/trans/debuginfo/mod.rs b/src/librustc_trans/trans/debuginfo/mod.rs index ebd2b7ea41811..a08f33c889994 100644 --- a/src/librustc_trans/trans/debuginfo/mod.rs +++ b/src/librustc_trans/trans/debuginfo/mod.rs @@ -351,7 +351,8 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // somehow (storing a path in the hir_map, or construct a path using the // enclosing function). let (linkage_name, containing_scope) = if has_path { - let namespace_node = namespace_for_item(cx, DefId::local(fn_ast_id)); + let fn_ast_def_id = cx.tcx().map.local_def_id(fn_ast_id); + let namespace_node = namespace_for_item(cx, fn_ast_def_id); let linkage_name = namespace_node.mangled_name_of_contained_item( &function_name[..]); let containing_scope = namespace_node.scope; diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 22d624be6fcc8..bf5f20d72e3f5 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -30,7 +30,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) // Already inline debug!("instantiate_inline({}): already inline as node id {}", ccx.tcx().item_path_str(fn_id), node_id); - return Some(DefId::local(node_id)); + let node_def_id = ccx.tcx().map.local_def_id(node_id); + return Some(node_def_id); } Some(&None) => { return None; // Not inlinable @@ -144,8 +145,9 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) // reuse that code, it needs to be able to look up the traits for // inlined items. let ty_trait_item = ccx.tcx().impl_or_trait_item(fn_id).clone(); + let trait_item_def_id = ccx.tcx().map.local_def_id(trait_item.id); ccx.tcx().impl_or_trait_items.borrow_mut() - .insert(DefId::local(trait_item.id), ty_trait_item); + .insert(trait_item_def_id, ty_trait_item); // If this is a default method, we can't look up the // impl type. But we aren't going to translate anyways, so @@ -185,7 +187,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) } }; - Some(DefId::local(inline_id)) + let inline_def_id = ccx.tcx().map.local_def_id(inline_id); + Some(inline_def_id) } pub fn get_local_instance(ccx: &CrateContext, fn_id: DefId) diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 846ddf2f26a2f..c424245facca7 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -168,12 +168,13 @@ pub fn ast_region_to_region(tcx: &ty::ctxt, lifetime: &hir::Lifetime) } Some(&rl::DefLateBoundRegion(debruijn, id)) => { - ty::ReLateBound(debruijn, ty::BrNamed(DefId::local(id), lifetime.name)) + ty::ReLateBound(debruijn, ty::BrNamed(tcx.map.local_def_id(id), lifetime.name)) } Some(&rl::DefEarlyBoundRegion(space, index, id)) => { + let def_id = tcx.map.local_def_id(id); ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: id, + param_id: def_id, space: space, index: index, name: lifetime.name @@ -183,7 +184,7 @@ pub fn ast_region_to_region(tcx: &ty::ctxt, lifetime: &hir::Lifetime) Some(&rl::DefFreeRegion(scope, id)) => { ty::ReFree(ty::FreeRegion { scope: tcx.region_maps.item_extent(scope.node_id), - bound_region: ty::BrNamed(DefId::local(id), + bound_region: ty::BrNamed(tcx.map.local_def_id(id), lifetime.name) }) } @@ -1264,7 +1265,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, (_, def::DefSelfTy(Some(trait_did), Some((impl_id, _)))) => { // `Self` in an impl of a trait - we have a concrete self type and a // trait reference. - let trait_ref = tcx.impl_trait_ref(DefId::local(impl_id)).unwrap(); + let trait_ref = tcx.impl_trait_ref(tcx.map.local_def_id(impl_id)).unwrap(); let trait_ref = if let Some(free_substs) = this.get_free_substs() { trait_ref.subst(tcx, free_substs) } else { @@ -1333,7 +1334,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, let item = trait_items.iter() .find(|i| i.name == assoc_name) .expect("missing associated type"); - DefId::local(item.id) + tcx.map.local_def_id(item.id) } _ => unreachable!() } @@ -1639,7 +1640,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, } else if let Some(hir::QSelf { position: 0, .. }) = *maybe_qself { // Create some fake resolution that can't possibly be a type. def::PathResolution { - base_def: def::DefMod(DefId::local(ast::CRATE_NODE_ID)), + base_def: def::DefMod(tcx.map.local_def_id(ast::CRATE_NODE_ID)), last_private: LastMod(AllPublic), depth: path.segments.len() } diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 546e337d746d9..8bcff22575563 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -9,7 +9,6 @@ // except according to those terms. use middle::def; -use middle::def_id::DefId; use middle::infer; use middle::pat_util::{PatIdMap, pat_id_map, pat_is_binding}; use middle::pat_util::pat_is_resolved_const; @@ -202,9 +201,10 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let path_res = if let Some(&d) = tcx.def_map.borrow().get(&pat.id) { d } else if qself.position == 0 { + // This is just a sentinel for finish_resolving_def_to_ty. + let sentinel = fcx.tcx().map.local_def_id(ast::CRATE_NODE_ID); def::PathResolution { - // This is just a sentinel for finish_resolving_def_to_ty. - base_def: def::DefMod(DefId::local(ast::CRATE_NODE_ID)), + base_def: def::DefMod(sentinel), last_private: LastMod(AllPublic), depth: path.segments.len() } diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index 82c898214c5b6..4f7a639539546 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -13,7 +13,6 @@ use super::{check_fn, Expectation, FnCtxt}; use astconv; -use middle::def_id::DefId; use middle::subst; use middle::ty::{self, ToPolyTraitRef, Ty}; use std::cmp; @@ -46,7 +45,7 @@ fn check_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, decl: &'tcx hir::FnDecl, body: &'tcx hir::Block, expected_sig: Option>) { - let expr_def_id = DefId::local(expr.id); + let expr_def_id = fcx.tcx().map.local_def_id(expr.id); debug!("check_closure opt_kind={:?} expected_sig={:?}", opt_kind, diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs index 8a114473e3c62..4afc610f63ea5 100644 --- a/src/librustc_typeck/check/intrinsic.rs +++ b/src/librustc_typeck/check/intrinsic.rs @@ -13,7 +13,6 @@ use astconv::AstConv; use intrinsics; -use middle::def_id::DefId; use middle::subst; use middle::ty::FnSig; use middle::ty::{self, Ty}; @@ -43,7 +42,7 @@ fn equate_intrinsic_type<'a, 'tcx>(tcx: &ty::ctxt<'tcx>, it: &hir::ForeignItem, variadic: false, }), })); - let i_ty = tcx.lookup_item_type(DefId::local(it.id)); + let i_ty = tcx.lookup_item_type(tcx.map.local_def_id(it.id)); let i_n_tps = i_ty.generics.types.len(subst::FnSpace); if i_n_tps != n_tps { span_err!(tcx.sess, it.span, E0094, @@ -365,7 +364,7 @@ pub fn check_platform_intrinsic_type(ccx: &CrateCtxt, }; let tcx = ccx.tcx; - let i_ty = tcx.lookup_item_type(DefId::local(it.id)); + let i_ty = tcx.lookup_item_type(tcx.map.local_def_id(it.id)); let i_n_tps = i_ty.generics.types.len(subst::FnSpace); let name = it.name.as_str(); diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 821615d0341f0..caa6b226d1b06 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -15,6 +15,7 @@ use CrateCtxt; use astconv::AstConv; use check::{self, FnCtxt}; +use front::map as hir_map; use middle::ty::{self, Ty, ToPolyTraitRef, ToPredicate, HasTypeFlags}; use middle::def; use middle::def_id::DefId; @@ -385,14 +386,16 @@ pub fn all_traits<'a>(ccx: &'a CrateCtxt) -> AllTraits<'a> { // Crate-local: // // meh. - struct Visitor<'a> { + struct Visitor<'a, 'tcx:'a> { + map: &'a hir_map::Map<'tcx>, traits: &'a mut AllTraitsVec, } - impl<'v, 'a> visit::Visitor<'v> for Visitor<'a> { + impl<'v, 'a, 'tcx> visit::Visitor<'v> for Visitor<'a, 'tcx> { fn visit_item(&mut self, i: &'v hir::Item) { match i.node { hir::ItemTrait(..) => { - self.traits.push(TraitInfo::new(DefId::local(i.id))); + let def_id = self.map.local_def_id(i.id); + self.traits.push(TraitInfo::new(def_id)); } _ => {} } @@ -400,6 +403,7 @@ pub fn all_traits<'a>(ccx: &'a CrateCtxt) -> AllTraits<'a> { } } visit::walk_crate(&mut Visitor { + map: &ccx.tcx.map, traits: &mut traits }, ccx.tcx.map.krate()); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 59da69d3696c3..7f4b1095cb596 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -688,7 +688,7 @@ pub fn check_struct(ccx: &CrateCtxt, id: ast::NodeId, span: Span) { check_representable(tcx, span, id, "struct"); - if tcx.lookup_simd(DefId::local(id)) { + if tcx.lookup_simd(ccx.tcx.map.local_def_id(id)) { check_simd(tcx, span, id); } } @@ -696,7 +696,7 @@ pub fn check_struct(ccx: &CrateCtxt, id: ast::NodeId, span: Span) { pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx hir::Item) { debug!("check_item_type(it.id={}, it.name={})", it.id, - ccx.tcx.item_path_str(DefId::local(it.id))); + ccx.tcx.item_path_str(ccx.tcx.map.local_def_id(it.id))); let _indenter = indenter(); match it.node { // Consts can play a role in type-checking, so they are included here. @@ -711,7 +711,7 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx hir::Item) { hir::ItemFn(..) => {} // entirely within check_item_body hir::ItemImpl(_, _, _, _, _, ref impl_items) => { debug!("ItemImpl {} with id {}", it.name, it.id); - match ccx.tcx.impl_trait_ref(DefId::local(it.id)) { + match ccx.tcx.impl_trait_ref(ccx.tcx.map.local_def_id(it.id)) { Some(impl_trait_ref) => { check_impl_items_against_trait(ccx, it.span, @@ -742,7 +742,7 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx hir::Item) { } } else { for item in &m.items { - let pty = ccx.tcx.lookup_item_type(DefId::local(item.id)); + let pty = ccx.tcx.lookup_item_type(ccx.tcx.map.local_def_id(item.id)); if !pty.generics.types.is_empty() { span_err!(ccx.tcx.sess, item.span, E0044, "foreign items may not have type parameters"); @@ -764,18 +764,18 @@ pub fn check_item_type<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx hir::Item) { pub fn check_item_body<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx hir::Item) { debug!("check_item_body(it.id={}, it.name={})", it.id, - ccx.tcx.item_path_str(DefId::local(it.id))); + ccx.tcx.item_path_str(ccx.tcx.map.local_def_id(it.id))); let _indenter = indenter(); match it.node { hir::ItemFn(ref decl, _, _, _, _, ref body) => { - let fn_pty = ccx.tcx.lookup_item_type(DefId::local(it.id)); + let fn_pty = ccx.tcx.lookup_item_type(ccx.tcx.map.local_def_id(it.id)); let param_env = ParameterEnvironment::for_item(ccx.tcx, it.id); check_bare_fn(ccx, &**decl, &**body, it.id, it.span, fn_pty.ty, param_env); } hir::ItemImpl(_, _, _, _, _, ref impl_items) => { debug!("ItemImpl {} with id {}", it.name, it.id); - let impl_pty = ccx.tcx.lookup_item_type(DefId::local(it.id)); + let impl_pty = ccx.tcx.lookup_item_type(ccx.tcx.map.local_def_id(it.id)); for impl_item in impl_items { match impl_item.node { @@ -793,7 +793,7 @@ pub fn check_item_body<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx hir::Item) { } } hir::ItemTrait(_, _, _, ref trait_items) => { - let trait_def = ccx.tcx.lookup_trait_def(DefId::local(it.id)); + let trait_def = ccx.tcx.lookup_trait_def(ccx.tcx.map.local_def_id(it.id)); for trait_item in trait_items { match trait_item.node { hir::ConstTraitItem(_, Some(ref expr)) => { @@ -912,7 +912,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // Check existing impl methods to see if they are both present in trait // and compatible with trait signature for impl_item in impl_items { - let ty_impl_item = ccx.tcx.impl_or_trait_item(DefId::local(impl_item.id)); + let ty_impl_item = ccx.tcx.impl_or_trait_item(ccx.tcx.map.local_def_id(impl_item.id)); let ty_trait_item = trait_items.iter() .find(|ac| ac.name() == ty_impl_item.name()) .unwrap_or_else(|| { @@ -1954,7 +1954,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .unwrap_or(type_variable::Default { ty: self.infcx().next_ty_var(), origin_span: codemap::DUMMY_SP, - def_id: DefId::local(0) // what do I put here? + def_id: self.tcx().map.local_def_id(0) // what do I put here? }); // This is to ensure that we elimnate any non-determinism from the error @@ -3357,7 +3357,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } else if let Some(hir::QSelf { position: 0, .. }) = *maybe_qself { // Create some fake resolution that can't possibly be a type. def::PathResolution { - base_def: def::DefMod(DefId::local(ast::CRATE_NODE_ID)), + base_def: def::DefMod(tcx.map.local_def_id(ast::CRATE_NODE_ID)), last_private: LastMod(AllPublic), depth: path.segments.len() } @@ -4109,7 +4109,7 @@ fn check_const<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, let inh = static_inherited_fields(ccx, &tables); let rty = ccx.tcx.node_id_to_type(id); let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(rty), e.id); - let declty = fcx.ccx.tcx.lookup_item_type(DefId::local(id)).ty; + let declty = fcx.ccx.tcx.lookup_item_type(ccx.tcx.map.local_def_id(id)).ty; check_const_with_ty(&fcx, sp, e, declty); } @@ -4237,7 +4237,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, } } - let def_id = DefId::local(id); + let def_id = ccx.tcx.map.local_def_id(id); let variants = &ccx.tcx.lookup_adt_def(def_id).variants; for (v, variant) in vs.iter().zip(variants.iter()) { diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index f9f711a1a6316..590b7e50e9438 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -43,7 +43,6 @@ use super::FnCtxt; use check::demand; -use middle::def_id::DefId; use middle::expr_use_visitor as euv; use middle::mem_categorization as mc; use middle::ty::{self, Ty}; @@ -116,7 +115,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { capture_clause: hir::CaptureClause, _body: &hir::Block) { - let closure_def_id = DefId::local(expr.id); + let closure_def_id = self.tcx().map.local_def_id(expr.id); if !self.fcx.inh.tables.borrow().closure_kinds.contains_key(&closure_def_id) { self.closures_with_inferred_kinds.insert(expr.id); self.fcx.inh.tables.borrow_mut().closure_kinds @@ -127,7 +126,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { self.tcx().with_freevars(expr.id, |freevars| { for freevar in freevars { - let var_node_id = freevar.def.local_node_id(); + let var_node_id = freevar.def.node_id(); let upvar_id = ty::UpvarId { var_id: var_node_id, closure_expr_id: expr.id }; debug!("seed upvar_id {:?}", upvar_id); @@ -215,7 +214,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> { // Now we must process and remove any deferred resolutions, // since we have a concrete closure kind. - let closure_def_id = DefId::local(id); + let closure_def_id = self.fcx.tcx().map.local_def_id(id); if self.closures_with_inferred_kinds.contains(&id) { let mut deferred_call_resolutions = self.fcx.remove_deferred_call_resolutions(closure_def_id); @@ -469,7 +468,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> { return; } - let closure_def_id = DefId::local(closure_id); + let closure_def_id = self.fcx.tcx().map.local_def_id(closure_id); let closure_kinds = &mut self.fcx.inh.tables.borrow_mut().closure_kinds; let existing_kind = *closure_kinds.get(&closure_def_id).unwrap(); diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index 70983b89ed5c8..b5cf069bda684 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -12,7 +12,6 @@ use astconv::AstConv; use check::{FnCtxt, Inherited, blank_fn_ctxt, regionck, wfcheck}; use constrained_type_params::{identify_constrained_type_params, Parameter}; use CrateCtxt; -use middle::def_id::DefId; use middle::region; use middle::subst::{self, TypeSpace, FnSpace, ParamSpace, SelfSpace}; use middle::traits; @@ -57,7 +56,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let ccx = self.ccx; debug!("check_item_well_formed(it.id={}, it.name={})", item.id, - ccx.tcx.item_path_str(DefId::local(item.id))); + ccx.tcx.item_path_str(ccx.tcx.map.local_def_id(item.id))); match item.node { /// Right now we check that every default trait implementation @@ -81,7 +80,8 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { self.check_impl(item); } hir::ItemImpl(_, hir::ImplPolarity::Negative, _, Some(_), _, _) => { - let trait_ref = ccx.tcx.impl_trait_ref(DefId::local(item.id)).unwrap(); + let item_def_id = ccx.tcx.map.local_def_id(item.id); + let trait_ref = ccx.tcx.impl_trait_ref(item_def_id).unwrap(); ccx.tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id); match ccx.tcx.lang_items.to_builtin_kind(trait_ref.def_id) { Some(ty::BoundSend) | Some(ty::BoundSync) => {} @@ -117,9 +117,9 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { } hir::ItemTrait(_, _, _, ref items) => { let trait_predicates = - ccx.tcx.lookup_predicates(DefId::local(item.id)); + ccx.tcx.lookup_predicates(ccx.tcx.map.local_def_id(item.id)); reject_non_type_param_bounds(ccx.tcx, item.span, &trait_predicates); - if ccx.tcx.trait_has_default_impl(DefId::local(item.id)) { + if ccx.tcx.trait_has_default_impl(ccx.tcx.map.local_def_id(item.id)) { if !items.is_empty() { wfcheck::error_380(ccx, item.span); } @@ -133,7 +133,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { F: for<'fcx> FnMut(&mut CheckTypeWellFormedVisitor<'ccx, 'tcx>, &FnCtxt<'fcx, 'tcx>), { let ccx = self.ccx; - let item_def_id = DefId::local(item.id); + let item_def_id = ccx.tcx.map.local_def_id(item.id); let type_scheme = ccx.tcx.lookup_item_type(item_def_id); let type_predicates = ccx.tcx.lookup_predicates(item_def_id); reject_non_type_param_bounds(ccx.tcx, item.span, &type_predicates); @@ -194,7 +194,8 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { Some(&mut this.cache)); debug!("check_item_type at bounds_checker.scope: {:?}", bounds_checker.scope); - let type_scheme = fcx.tcx().lookup_item_type(DefId::local(item.id)); + let item_def_id = fcx.tcx().map.local_def_id(item.id); + let type_scheme = fcx.tcx().lookup_item_type(item_def_id); let item_ty = fcx.instantiate_type_scheme(item.span, &fcx.inh .infcx @@ -230,7 +231,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { // Similarly, obtain an "inside" reference to the trait // that the impl implements. - let trait_ref = match fcx.tcx().impl_trait_ref(DefId::local(item.id)) { + let trait_ref = match fcx.tcx().impl_trait_ref(fcx.tcx().map.local_def_id(item.id)) { None => { return; } Some(t) => { t } }; @@ -279,7 +280,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { item: &hir::Item, ast_generics: &hir::Generics) { - let item_def_id = DefId::local(item.id); + let item_def_id = self.tcx().map.local_def_id(item.id); let ty_predicates = self.tcx().lookup_predicates(item_def_id); let variances = self.tcx().item_variances(item_def_id); @@ -431,7 +432,7 @@ impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { match fk { FnKind::Closure | FnKind::ItemFn(..) => {} FnKind::Method(..) => { - match self.tcx().impl_or_trait_item(DefId::local(id)) { + match self.tcx().impl_or_trait_item(self.tcx().map.local_def_id(id)) { ty::ImplOrTraitItem::MethodTraitItem(ty_method) => { reject_shadowing_type_parameters(self.tcx(), span, &ty_method.generics) } @@ -444,7 +445,7 @@ impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { fn visit_trait_item(&mut self, trait_item: &'v hir::TraitItem) { if let hir::MethodTraitItem(_, None) = trait_item.node { - match self.tcx().impl_or_trait_item(DefId::local(trait_item.id)) { + match self.tcx().impl_or_trait_item(self.tcx().map.local_def_id(trait_item.id)) { ty::ImplOrTraitItem::MethodTraitItem(ty_method) => { reject_non_type_param_bounds( self.tcx(), diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 2c6879891b1c9..b8d942ad22703 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -63,7 +63,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let ccx = self.ccx; debug!("check_item_well_formed(it.id={}, it.name={})", item.id, - ccx.tcx.item_path_str(DefId::local(item.id))); + ccx.tcx.item_path_str(ccx.tcx.map.local_def_id(item.id))); match item.node { /// Right now we check that every default trait implementation @@ -90,7 +90,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { hir::ItemImpl(_, hir::ImplPolarity::Negative, _, Some(_), _, _) => { // FIXME(#27579) what amount of WF checking do we need for neg impls? - let trait_ref = ccx.tcx.impl_trait_ref(DefId::local(item.id)).unwrap(); + let trait_ref = ccx.tcx.impl_trait_ref(ccx.tcx.map.local_def_id(item.id)).unwrap(); ccx.tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id); match ccx.tcx.lang_items.to_builtin_kind(trait_ref.def_id) { Some(ty::BoundSend) | Some(ty::BoundSync) => {} @@ -137,7 +137,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; let free_id = fcx.inh.infcx.parameter_environment.free_id; - let item = fcx.tcx().impl_or_trait_item(DefId::local(item_id)); + let item = fcx.tcx().impl_or_trait_item(fcx.tcx().map.local_def_id(item_id)); let mut implied_bounds = match item.container() { ty::TraitContainer(_) => vec![], @@ -216,7 +216,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { } let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; - let predicates = fcx.tcx().lookup_predicates(DefId::local(item.id)); + let predicates = fcx.tcx().lookup_predicates(fcx.tcx().map.local_def_id(item.id)); let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); this.check_where_clauses(fcx, item.span, &predicates); @@ -228,7 +228,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { item: &hir::Item, items: &[P]) { - let trait_def_id = DefId::local(item.id); + let trait_def_id = self.tcx().map.local_def_id(item.id); if self.ccx.tcx.trait_has_default_impl(trait_def_id) { if !items.is_empty() { @@ -251,7 +251,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { { self.with_item_fcx(item, |fcx, this| { let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; - let type_scheme = fcx.tcx().lookup_item_type(DefId::local(item.id)); + let type_scheme = fcx.tcx().lookup_item_type(fcx.tcx().map.local_def_id(item.id)); let item_ty = fcx.instantiate_type_scheme(item.span, free_substs, &type_scheme.ty); let bare_fn_ty = match item_ty.sty { ty::TyBareFn(_, ref bare_fn_ty) => bare_fn_ty, @@ -260,7 +260,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { } }; - let predicates = fcx.tcx().lookup_predicates(DefId::local(item.id)); + let predicates = fcx.tcx().lookup_predicates(fcx.tcx().map.local_def_id(item.id)); let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); let mut implied_bounds = vec![]; @@ -276,7 +276,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { debug!("check_item_type: {:?}", item); self.with_item_fcx(item, |fcx, this| { - let type_scheme = fcx.tcx().lookup_item_type(DefId::local(item.id)); + let type_scheme = fcx.tcx().lookup_item_type(fcx.tcx().map.local_def_id(item.id)); let item_ty = fcx.instantiate_type_scheme(item.span, &fcx.inh .infcx @@ -299,7 +299,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { self.with_item_fcx(item, |fcx, this| { let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; - let item_def_id = DefId::local(item.id); + let item_def_id = fcx.tcx().map.local_def_id(item.id); match *ast_trait_ref { Some(ref ast_trait_ref) => { @@ -328,7 +328,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); this.check_where_clauses(fcx, item.span, &predicates); - impl_implied_bounds(fcx, DefId::local(item.id), item.span) + impl_implied_bounds(fcx, fcx.tcx().map.local_def_id(item.id), item.span) }); } @@ -386,7 +386,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { item: &hir::Item, ast_generics: &hir::Generics) { - let item_def_id = DefId::local(item.id); + let item_def_id = self.tcx().map.local_def_id(item.id); let ty_predicates = self.tcx().lookup_predicates(item_def_id); let variances = self.tcx().item_variances(item_def_id); diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 5c3c95ba4d296..ddb11c910b19e 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -139,7 +139,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { fn check_implementation(&self, item: &Item) { let tcx = self.crate_context.tcx; - let impl_did = DefId::local(item.id); + let impl_did = tcx.map.local_def_id(item.id); let self_type = tcx.lookup_item_type(impl_did); // If there are no traits, then this implementation must have a @@ -195,15 +195,16 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { match item.node { ItemImpl(_, _, _, _, _, ref impl_items) => { impl_items.iter().map(|impl_item| { + let impl_def_id = self.crate_context.tcx.map.local_def_id(impl_item.id); match impl_item.node { hir::ConstImplItem(..) => { - ConstTraitItemId(DefId::local(impl_item.id)) + ConstTraitItemId(impl_def_id) } hir::MethodImplItem(..) => { - MethodTraitItemId(DefId::local(impl_item.id)) + MethodTraitItemId(impl_def_id) } hir::TypeImplItem(_) => { - TypeTraitItemId(DefId::local(impl_item.id)) + TypeTraitItemId(impl_def_id) } } }).collect() diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index 4f1c958b6ddcd..f796f7fe9f9bd 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -64,7 +64,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { /// to prevent inundating the user with a bunch of similar error /// reports. fn check_item(&self, item: &hir::Item) { - let def_id = DefId::local(item.id); + let def_id = self.tcx.map.local_def_id(item.id); match item.node { hir::ItemImpl(_, _, _, None, _, _) => { // For inherent impls, self type must be a nominal type diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index f257dfb62c912..a2c8e8fd131fc 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -178,20 +178,20 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { // look for another default impl; note that due to the // general orphan/coherence rules, it must always be // in this crate. - let impl_def_id = DefId::local(item.id); + let impl_def_id = self.tcx.map.local_def_id(item.id); let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap(); let prev_default_impl = self.default_impls.insert(trait_ref.def_id, item.id); match prev_default_impl { Some(prev_id) => { self.report_overlap_error(trait_ref.def_id, impl_def_id, - DefId::local(prev_id)); + self.tcx.map.local_def_id(prev_id)); } None => { } } } hir::ItemImpl(_, _, _, Some(_), ref self_ty, _) => { - let impl_def_id = DefId::local(item.id); + let impl_def_id = self.tcx.map.local_def_id(item.id); let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap(); let trait_def_id = trait_ref.def_id; match trait_ref.self_ty().sty { diff --git a/src/librustc_typeck/coherence/unsafety.rs b/src/librustc_typeck/coherence/unsafety.rs index b739709e622c2..f7b10b9001340 100644 --- a/src/librustc_typeck/coherence/unsafety.rs +++ b/src/librustc_typeck/coherence/unsafety.rs @@ -11,7 +11,6 @@ //! Unsafety checker: every impl either implements a trait defined in this //! crate or pertains to a type defined in this crate. -use middle::def_id::DefId; use middle::ty; use rustc_front::visit; use rustc_front::hir; @@ -30,7 +29,7 @@ impl<'cx, 'tcx, 'v> UnsafetyChecker<'cx, 'tcx> { fn check_unsafety_coherence(&mut self, item: &'v hir::Item, unsafety: hir::Unsafety, polarity: hir::ImplPolarity) { - match self.tcx.impl_trait_ref(DefId::local(item.id)) { + match self.tcx.impl_trait_ref(self.tcx.map.local_def_id(item.id)) { None => { // Inherent impl. match unsafety { diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 5811c3c72f789..e24d3f340b6e7 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -199,7 +199,7 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { } fn method_ty(&self, method_id: ast::NodeId) -> Rc> { - let def_id = DefId::local(method_id); + let def_id = self.tcx.map.local_def_id(method_id); match *self.tcx.impl_or_trait_items.borrow().get(&def_id).unwrap() { ty::MethodTraitItem(ref mty) => mty.clone(), _ => { @@ -562,7 +562,7 @@ fn is_param<'tcx>(tcx: &ty::ctxt<'tcx>, path_res.depth == 0 && def_id.node == param_id } def::DefTyParam(_, _, def_id, _) => { - path_res.depth == 0 && def_id == DefId::local(param_id) + path_res.depth == 0 && def_id == tcx.map.local_def_id(param_id) } _ => { false @@ -592,7 +592,7 @@ fn convert_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, astconv::ty_of_method(&ccx.icx(&(rcvr_ty_predicates, &sig.generics)), sig, untransformed_rcvr_ty); - let def_id = DefId::local(id); + let def_id = ccx.tcx.map.local_def_id(id); let ty_method = ty::Method::new(name, ty_generics, ty_generic_predicates, @@ -632,12 +632,12 @@ fn convert_field<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, write_ty_to_tcx(ccx.tcx, v.node.id, tt); /* add the field to the tcache */ - ccx.tcx.register_item_type(DefId::local(v.node.id), + ccx.tcx.register_item_type(ccx.tcx.map.local_def_id(v.node.id), ty::TypeScheme { generics: struct_generics.clone(), ty: tt }); - ccx.tcx.predicates.borrow_mut().insert(DefId::local(v.node.id), + ccx.tcx.predicates.borrow_mut().insert(ccx.tcx.map.local_def_id(v.node.id), struct_predicates.clone()); } @@ -649,7 +649,7 @@ fn convert_associated_const<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, ty: ty::Ty<'tcx>, has_value: bool) { - ccx.tcx.predicates.borrow_mut().insert(DefId::local(id), + ccx.tcx.predicates.borrow_mut().insert(ccx.tcx.map.local_def_id(id), ty::GenericPredicates::empty()); write_ty_to_tcx(ccx.tcx, id, ty); @@ -657,13 +657,13 @@ fn convert_associated_const<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, let associated_const = Rc::new(ty::AssociatedConst { name: name, vis: vis, - def_id: DefId::local(id), + def_id: ccx.tcx.map.local_def_id(id), container: container, ty: ty, has_value: has_value }); ccx.tcx.impl_or_trait_items.borrow_mut() - .insert(DefId::local(id), ty::ConstTraitItem(associated_const)); + .insert(ccx.tcx.map.local_def_id(id), ty::ConstTraitItem(associated_const)); } fn convert_associated_type<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, @@ -677,11 +677,11 @@ fn convert_associated_type<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, name: name, vis: vis, ty: ty, - def_id: DefId::local(id), + def_id: ccx.tcx.map.local_def_id(id), container: container }); ccx.tcx.impl_or_trait_items.borrow_mut() - .insert(DefId::local(id), ty::TypeTraitItem(associated_type)); + .insert(ccx.tcx.map.local_def_id(id), ty::TypeTraitItem(associated_type)); } fn convert_methods<'a,'tcx,'i,I>(ccx: &CrateCtxt<'a, 'tcx>, @@ -752,7 +752,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { let (scheme, predicates) = convert_typed_item(ccx, it); write_ty_to_tcx(tcx, it.id, scheme.ty); convert_enum_variant_types(ccx, - tcx.lookup_adt_def_master(DefId::local(it.id)), + tcx.lookup_adt_def_master(ccx.tcx.map.local_def_id(it.id)), scheme, predicates, &enum_definition.variants); @@ -766,7 +766,8 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { tcx.record_trait_has_default_impl(trait_ref.def_id); - tcx.impl_trait_refs.borrow_mut().insert(DefId::local(it.id), Some(trait_ref)); + tcx.impl_trait_refs.borrow_mut().insert(ccx.tcx.map.local_def_id(it.id), + Some(trait_ref)); } hir::ItemImpl(_, _, ref generics, @@ -783,21 +784,21 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { let selfty = ccx.icx(&ty_predicates).to_ty(&ExplicitRscope, &**selfty); write_ty_to_tcx(tcx, it.id, selfty); - tcx.register_item_type(DefId::local(it.id), + tcx.register_item_type(ccx.tcx.map.local_def_id(it.id), TypeScheme { generics: ty_generics.clone(), ty: selfty }); - tcx.predicates.borrow_mut().insert(DefId::local(it.id), + tcx.predicates.borrow_mut().insert(ccx.tcx.map.local_def_id(it.id), ty_predicates.clone()); if let &Some(ref ast_trait_ref) = opt_trait_ref { tcx.impl_trait_refs.borrow_mut().insert( - DefId::local(it.id), + ccx.tcx.map.local_def_id(it.id), Some(astconv::instantiate_mono_trait_ref(&ccx.icx(&ty_predicates), &ExplicitRscope, ast_trait_ref, Some(selfty))) ); } else { - tcx.impl_trait_refs.borrow_mut().insert(DefId::local(it.id), None); + tcx.impl_trait_refs.borrow_mut().insert(ccx.tcx.map.local_def_id(it.id), None); } @@ -839,12 +840,12 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { if let hir::ConstImplItem(ref ty, _) = impl_item.node { let ty = ccx.icx(&ty_predicates) .to_ty(&ExplicitRscope, &*ty); - tcx.register_item_type(DefId::local(impl_item.id), + tcx.register_item_type(ccx.tcx.map.local_def_id(impl_item.id), TypeScheme { generics: ty_generics.clone(), ty: ty, }); - convert_associated_const(ccx, ImplContainer(DefId::local(it.id)), + convert_associated_const(ccx, ImplContainer(ccx.tcx.map.local_def_id(it.id)), impl_item.name, impl_item.id, impl_item.vis.inherit_from(parent_visibility), ty, true /* has_value */); @@ -861,7 +862,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { let typ = ccx.icx(&ty_predicates).to_ty(&ExplicitRscope, ty); - convert_associated_type(ccx, ImplContainer(DefId::local(it.id)), + convert_associated_type(ccx, ImplContainer(ccx.tcx.map.local_def_id(it.id)), impl_item.name, impl_item.id, impl_item.vis, Some(typ)); } @@ -880,7 +881,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { } }); convert_methods(ccx, - ImplContainer(DefId::local(it.id)), + ImplContainer(ccx.tcx.map.local_def_id(it.id)), methods, selfty, &ty_generics, @@ -900,15 +901,15 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { enforce_impl_params_are_constrained(tcx, generics, - DefId::local(it.id), + ccx.tcx.map.local_def_id(it.id), impl_items); }, hir::ItemTrait(_, _, _, ref trait_items) => { let trait_def = trait_def_of_item(ccx, it); let _: Result<(), ErrorReported> = // any error is already reported, can ignore - ccx.ensure_super_predicates(it.span, DefId::local(it.id)); + ccx.ensure_super_predicates(it.span, ccx.tcx.map.local_def_id(it.id)); convert_trait_predicates(ccx, it); - let trait_predicates = tcx.lookup_predicates(DefId::local(it.id)); + let trait_predicates = tcx.lookup_predicates(ccx.tcx.map.local_def_id(it.id)); debug!("convert: trait_bounds={:?}", trait_predicates); @@ -918,14 +919,18 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { hir::ConstTraitItem(ref ty, ref default) => { let ty = ccx.icx(&trait_predicates) .to_ty(&ExplicitRscope, ty); - tcx.register_item_type(DefId::local(trait_item.id), + tcx.register_item_type(ccx.tcx.map.local_def_id(trait_item.id), TypeScheme { generics: trait_def.generics.clone(), ty: ty, }); - convert_associated_const(ccx, TraitContainer(DefId::local(it.id)), - trait_item.name, trait_item.id, - hir::Public, ty, default.is_some()); + convert_associated_const(ccx, + TraitContainer(ccx.tcx.map.local_def_id(it.id)), + trait_item.name, + trait_item.id, + hir::Public, + ty, + default.is_some()) } _ => {} } @@ -939,8 +944,11 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { |ty| ccx.icx(&trait_predicates).to_ty(&ExplicitRscope, &ty) }); - convert_associated_type(ccx, TraitContainer(DefId::local(it.id)), - trait_item.name, trait_item.id, hir::Public, + convert_associated_type(ccx, + TraitContainer(ccx.tcx.map.local_def_id(it.id)), + trait_item.name, + trait_item.id, + hir::Public, typ); } _ => {} @@ -957,7 +965,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { // Run convert_methods on the trait methods. convert_methods(ccx, - TraitContainer(DefId::local(it.id)), + TraitContainer(ccx.tcx.map.local_def_id(it.id)), methods, tcx.mk_self_type(), &trait_def.generics, @@ -965,7 +973,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { // Add an entry mapping let trait_item_def_ids = Rc::new(trait_items.iter().map(|trait_item| { - let def_id = DefId::local(trait_item.id); + let def_id = ccx.tcx.map.local_def_id(trait_item.id); match trait_item.node { hir::ConstTraitItem(..) => { ty::ConstTraitItemId(def_id) @@ -978,7 +986,8 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { } } }).collect()); - tcx.trait_item_def_ids.borrow_mut().insert(DefId::local(it.id), trait_item_def_ids); + tcx.trait_item_def_ids.borrow_mut().insert(ccx.tcx.map.local_def_id(it.id), + trait_item_def_ids); // This must be done after `collect_trait_methods` so that // we have a method type stored for every method. @@ -999,7 +1008,8 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { let (scheme, predicates) = convert_typed_item(ccx, it); write_ty_to_tcx(tcx, it.id, scheme.ty); - let variant = tcx.lookup_adt_def_master(DefId::local(it.id)).struct_variant(); + let it_def_id = ccx.tcx.map.local_def_id(it.id); + let variant = tcx.lookup_adt_def_master(it_def_id).struct_variant(); for (f, ty_f) in struct_def.fields.iter().zip(variant.fields.iter()) { convert_field(ccx, &scheme.generics, &predicates, f, ty_f) @@ -1037,14 +1047,14 @@ fn convert_variant_ctor<'a, 'tcx>(tcx: &ty::ctxt<'tcx>, .iter() .map(|field| field.unsubst_ty()) .collect(); - tcx.mk_ctor_fn(DefId::local(ctor_id), + tcx.mk_ctor_fn(tcx.map.local_def_id(ctor_id), &inputs[..], scheme.ty) } }; write_ty_to_tcx(tcx, ctor_id, ctor_ty); - tcx.predicates.borrow_mut().insert(DefId::local(ctor_id), predicates); - tcx.register_item_type(DefId::local(ctor_id), + tcx.predicates.borrow_mut().insert(tcx.map.local_def_id(ctor_id), predicates); + tcx.register_item_type(tcx.map.local_def_id(ctor_id), TypeScheme { generics: scheme.generics, ty: ctor_ty @@ -1096,7 +1106,7 @@ fn convert_struct_variant<'tcx>(tcx: &ty::ctxt<'tcx>, def: &hir::StructDef) -> ty::VariantDefData<'tcx, 'tcx> { let mut seen_fields: FnvHashMap = FnvHashMap(); let fields = def.fields.iter().map(|f| { - let fid = DefId::local(f.node.id); + let fid = tcx.map.local_def_id(f.node.id); match f.node.kind { hir::NamedField(name, vis) => { let dup_span = seen_fields.get(&name).cloned(); @@ -1130,7 +1140,7 @@ fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>, -> ty::AdtDefMaster<'tcx> { - let did = DefId::local(it.id); + let did = tcx.map.local_def_id(it.id); tcx.intern_adt_def( did, ty::AdtKind::Struct, @@ -1207,7 +1217,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, disr: ty::Disr) -> ty::VariantDefData<'tcx, 'tcx> { - let did = DefId::local(v.node.id); + let did = tcx.map.local_def_id(v.node.id); let name = v.node.name; match v.node.kind { hir::TupleVariantKind(ref va) => { @@ -1217,7 +1227,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, disr_val: disr, fields: va.iter().map(|&hir::VariantArg { id, .. }| { ty::FieldDefData::new( - DefId::local(id), + tcx.map.local_def_id(id), special_idents::unnamed_field.name, hir::Visibility::Public ) @@ -1229,7 +1239,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, } } } - let did = DefId::local(it.id); + let did = tcx.map.local_def_id(it.id); let repr_hints = tcx.lookup_repr_hints(did); let (repr_type, repr_type_ty) = tcx.enum_repr_type(repr_hints.get(0)); let mut prev_disr = None; @@ -1243,7 +1253,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>, prev_disr = Some(disr); v }).collect(); - tcx.intern_adt_def(DefId::local(it.id), ty::AdtKind::Enum, variants) + tcx.intern_adt_def(tcx.map.local_def_id(it.id), ty::AdtKind::Enum, variants) } /// Ensures that the super-predicates of the trait with def-id @@ -1316,7 +1326,7 @@ fn ensure_super_predicates_step(ccx: &CrateCtxt, predicates: VecPerParamSpace::new(superbounds, vec![], vec![]) }; debug!("superpredicates for trait {:?} = {:?}", - DefId::local(item.id), + tcx.map.local_def_id(item.id), superpredicates); tcx.super_predicates.borrow_mut().insert(trait_def_id, superpredicates.clone()); @@ -1339,7 +1349,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, it: &hir::Item) -> &'tcx ty::TraitDef<'tcx> { - let def_id = DefId::local(it.id); + let def_id = ccx.tcx.map.local_def_id(it.id); let tcx = ccx.tcx; if let Some(def) = tcx.trait_defs.borrow().get(&def_id) { @@ -1402,12 +1412,15 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, generics.lifetimes .iter() .enumerate() - .map(|(i, def)| ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: def.lifetime.id, - space: TypeSpace, - index: i as u32, - name: def.lifetime.name - })) + .map(|(i, def)| { + let def_id = tcx.map.local_def_id(def.lifetime.id); + ty::ReEarlyBound(ty::EarlyBoundRegion { + param_id: def_id, + space: TypeSpace, + index: i as u32, + name: def.lifetime.name + }) + }) .collect(); // Start with the generics in the type parameters... @@ -1453,7 +1466,7 @@ fn convert_trait_predicates<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, it: &hir::Item) let tcx = ccx.tcx; let trait_def = trait_def_of_item(ccx, it); - let def_id = DefId::local(it.id); + let def_id = ccx.tcx.map.local_def_id(it.id); let (generics, items) = match it.node { hir::ItemTrait(_, ref generics, _, ref items) => (generics, items), @@ -1552,7 +1565,7 @@ fn type_scheme_of_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, -> ty::TypeScheme<'tcx> { memoized(&ccx.tcx.tcache, - DefId::local(it.id), + ccx.tcx.map.local_def_id(it.id), |_| compute_type_scheme_of_item(ccx, it)) } @@ -1569,7 +1582,7 @@ fn compute_type_scheme_of_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, hir::ItemFn(ref decl, unsafety, _, abi, ref generics, _) => { let ty_generics = ty_generics_for_fn(ccx, generics, &ty::Generics::empty()); let tofd = astconv::ty_of_bare_fn(&ccx.icx(generics), unsafety, abi, &**decl); - let ty = tcx.mk_fn(Some(DefId::local(it.id)), tcx.mk_bare_fn(tofd)); + let ty = tcx.mk_fn(Some(ccx.tcx.map.local_def_id(it.id)), tcx.mk_bare_fn(tofd)); ty::TypeScheme { ty: ty, generics: ty_generics } } hir::ItemTy(ref t, ref generics) => { @@ -1644,12 +1657,12 @@ fn convert_typed_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, } }; - let prev_predicates = tcx.predicates.borrow_mut().insert(DefId::local(it.id), + let prev_predicates = tcx.predicates.borrow_mut().insert(ccx.tcx.map.local_def_id(it.id), predicates.clone()); assert!(prev_predicates.is_none()); // Debugging aid. - if tcx.has_attr(DefId::local(it.id), "rustc_object_lifetime_default") { + if tcx.has_attr(ccx.tcx.map.local_def_id(it.id), "rustc_object_lifetime_default") { let object_lifetime_default_reprs: String = scheme.generics.types.iter() .map(|t| match t.object_lifetime_default { @@ -1672,7 +1685,7 @@ fn type_scheme_of_foreign_item<'a, 'tcx>( -> ty::TypeScheme<'tcx> { memoized(&ccx.tcx.tcache, - DefId::local(it.id), + ccx.tcx.map.local_def_id(it.id), |_| compute_type_scheme_of_foreign_item(ccx, it, abi)) } @@ -1717,7 +1730,8 @@ fn convert_foreign_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, } }; - let prev_predicates = tcx.predicates.borrow_mut().insert(DefId::local(it.id), predicates); + let prev_predicates = tcx.predicates.borrow_mut().insert(ccx.tcx.map.local_def_id(it.id), + predicates); assert!(prev_predicates.is_none()); } @@ -1741,7 +1755,7 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, -> ty::Generics<'tcx> { debug!("ty_generics_for_trait(trait_id={:?}, substs={:?})", - DefId::local(trait_id), substs); + ccx.tcx.map.local_def_id(trait_id), substs); let mut generics = ty_generics_for_type_or_impl(ccx, ast_generics); @@ -1757,8 +1771,8 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, space: SelfSpace, index: 0, name: special_idents::type_self.name, - def_id: DefId::local(param_id), - default_def_id: DefId::local(parent), + def_id: ccx.tcx.map.local_def_id(param_id), + default_def_id: ccx.tcx.map.local_def_id(parent), default: None, object_lifetime_default: ty::ObjectLifetimeDefault::BaseDefault, }; @@ -1877,9 +1891,10 @@ fn ty_generic_predicates<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, let early_lifetimes = early_bound_lifetimes_from_generics(space, ast_generics); for (index, param) in early_lifetimes.iter().enumerate() { let index = index as u32; + let def_id = tcx.map.local_def_id(param.lifetime.id); let region = ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: param.lifetime.id, + param_id: def_id, space: space, index: index, name: param.lifetime.name @@ -1965,7 +1980,7 @@ fn ty_generics<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, let def = ty::RegionParameterDef { name: l.lifetime.name, space: space, index: i as u32, - def_id: DefId::local(l.lifetime.id), + def_id: ccx.tcx.map.local_def_id(l.lifetime.id), bounds: bounds }; result.regions.push(space, def); } @@ -2033,8 +2048,8 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, space: space, index: index, name: param.name, - def_id: DefId::local(param.id), - default_def_id: DefId::local(parent), + def_id: ccx.tcx.map.local_def_id(param.id), + default_def_id: ccx.tcx.map.local_def_id(parent), default: default, object_lifetime_default: object_lifetime_default, }; @@ -2377,7 +2392,7 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( tcx.fold_regions(value, &mut false, |region, _| { match region { ty::ReEarlyBound(data) => { - let def_id = DefId::local(data.param_id); + let def_id = data.param_id; ty::ReFree(ty::FreeRegion { scope: scope, bound_region: ty::BrNamed(def_id, data.name) }) } @@ -2424,7 +2439,7 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, let lifetimes_in_associated_types: HashSet<_> = impl_items.iter() - .map(|item| tcx.impl_or_trait_item(DefId::local(item.id))) + .map(|item| tcx.impl_or_trait_item(tcx.map.local_def_id(item.id))) .filter_map(|item| match item { ty::TypeTraitItem(ref assoc_ty) => assoc_ty.ty, ty::ConstTraitItem(..) | ty::MethodTraitItem(..) => None @@ -2437,7 +2452,8 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, .collect(); for (index, lifetime_def) in ast_generics.lifetimes.iter().enumerate() { - let region = ty::EarlyBoundRegion { param_id: lifetime_def.lifetime.id, + let def_id = tcx.map.local_def_id(lifetime_def.lifetime.id); + let region = ty::EarlyBoundRegion { param_id: def_id, space: TypeSpace, index: index as u32, name: lifetime_def.lifetime.name }; diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index a11cd54b6580e..7156c9c6091a7 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -98,20 +98,20 @@ extern crate rustc; extern crate rustc_platform_intrinsics as intrinsics; extern crate rustc_front; +pub use rustc::front; pub use rustc::lint; pub use rustc::metadata; pub use rustc::middle; pub use rustc::session; pub use rustc::util; +use front::map as hir_map; use middle::def; -use middle::def_id::DefId; use middle::infer; use middle::subst; use middle::ty::{self, Ty, HasTypeFlags}; use session::config; use util::common::time; -use rustc::front::map as hir_map; use rustc_front::hir; use syntax::codemap::Span; @@ -239,7 +239,8 @@ fn check_main_fn_ty(ccx: &CrateCtxt, } _ => () } - let se_ty = tcx.mk_fn(Some(DefId::local(main_id)), tcx.mk_bare_fn(ty::BareFnTy { + let main_def_id = tcx.map.local_def_id(main_id); + let se_ty = tcx.mk_fn(Some(main_def_id), tcx.mk_bare_fn(ty::BareFnTy { unsafety: hir::Unsafety::Normal, abi: abi::Rust, sig: ty::Binder(ty::FnSig { @@ -285,7 +286,8 @@ fn check_start_fn_ty(ccx: &CrateCtxt, _ => () } - let se_ty = tcx.mk_fn(Some(DefId::local(start_id)), tcx.mk_bare_fn(ty::BareFnTy { + let se_ty = tcx.mk_fn(Some(ccx.tcx.map.local_def_id(start_id)), + tcx.mk_bare_fn(ty::BareFnTy { unsafety: hir::Unsafety::Normal, abi: abi::Rust, sig: ty::Binder(ty::FnSig { diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 4220e258ca5a9..86a97f305aa69 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -452,9 +452,10 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { // "invalid item id" from "item id with no // parameters". if self.num_inferred() == inferreds_on_entry { + let item_def_id = self.tcx.map.local_def_id(item_id); let newly_added = self.tcx.item_variance_map.borrow_mut().insert( - DefId::local(item_id), + item_def_id, self.empty_variances.clone()).is_none(); assert!(newly_added); } @@ -487,7 +488,7 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { param_id={}, \ inf_index={:?}, \ initial_variance={:?})", - self.tcx.item_path_str(DefId::local(item_id)), + self.tcx.item_path_str(self.tcx.map.local_def_id(item_id)), item_id, kind, space, index, param_id, inf_index, initial_variance); } @@ -597,8 +598,8 @@ fn add_constraints_from_crate<'a, 'tcx>(terms_cx: TermsContext<'a, 'tcx>, impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { fn visit_item(&mut self, item: &hir::Item) { - let did = DefId::local(item.id); let tcx = self.terms_cx.tcx; + let did = tcx.map.local_def_id(item.id); debug!("visit_item item={}", tcx.map.node_to_string(item.id)); @@ -1012,8 +1013,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance: VarianceTermPtr<'a>) { match region { ty::ReEarlyBound(ref data) => { - if self.is_to_be_inferred(data.param_id) { - let index = self.inferred_index(data.param_id); + let node_id = self.tcx().map.as_local_node_id(data.param_id).unwrap(); + if self.is_to_be_inferred(node_id) { + let index = self.inferred_index(node_id); self.add_constraint(index, variance); } } @@ -1164,7 +1166,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { item_id, item_variances); - let item_def_id = DefId::local(item_id); + let item_def_id = tcx.map.local_def_id(item_id); // For unit testing: check for a special "rustc_variance" // attribute and report an error with various results if found. diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 4ecaa46fb4546..e6580a2c03778 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -189,7 +189,7 @@ impl<'a, 'tcx> Clean for visit_ast::RustdocVisitor<'a, 'tcx> { attrs: child.attrs.clone(), visibility: Some(hir::Public), stability: None, - def_id: DefId::local(prim.to_node_id()), + def_id: cx.map.local_def_id(prim.to_node_id()), inner: PrimitiveItem(prim), }); } @@ -420,7 +420,7 @@ impl Clean for doctree::Module { source: whence.clean(cx), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), inner: ModuleItem(Module { is_crate: self.is_crate, items: items @@ -1088,7 +1088,7 @@ impl Clean for doctree::Function { source: self.whence.clean(cx), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), inner: FunctionItem(Function { decl: self.decl.clean(cx), generics: self.generics.clean(cx), @@ -1211,7 +1211,7 @@ impl Clean for doctree::Trait { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: TraitItem(Trait { @@ -1261,9 +1261,9 @@ impl Clean for hir::TraitItem { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.span.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: None, - stability: get_stability(cx, DefId::local(self.id)), + stability: get_stability(cx, cx.map.local_def_id(self.id)), inner: inner } } @@ -1294,9 +1294,9 @@ impl Clean for hir::ImplItem { name: Some(self.name.clean(cx)), source: self.span.clean(cx), attrs: self.attrs.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), - stability: get_stability(cx, DefId::local(self.id)), + stability: get_stability(cx, cx.map.local_def_id(self.id)), inner: inner } } @@ -1660,7 +1660,7 @@ impl<'tcx> Clean for ty::Ty<'tcx> { type_params: Vec::new(), where_predicates: Vec::new() }, - decl: (DefId::local(0), &fty.sig).clean(cx), + decl: (cx.map.local_def_id(0), &fty.sig).clean(cx), abi: fty.abi.to_string(), }), ty::TyStruct(def, substs) | @@ -1728,8 +1728,8 @@ impl Clean for hir::StructField { attrs: self.node.attrs.clean(cx), source: self.span.clean(cx), visibility: Some(vis), - stability: get_stability(cx, DefId::local(self.node.id)), - def_id: DefId::local(self.node.id), + stability: get_stability(cx, cx.map.local_def_id(self.node.id)), + def_id: cx.map.local_def_id(self.node.id), inner: StructFieldItem(TypedStructField(self.node.ty.clean(cx))), } } @@ -1782,7 +1782,7 @@ impl Clean for doctree::Struct { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: StructItem(Struct { @@ -1828,7 +1828,7 @@ impl Clean for doctree::Enum { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: EnumItem(Enum { @@ -1853,7 +1853,7 @@ impl Clean for doctree::Variant { source: self.whence.clean(cx), visibility: None, stability: self.stab.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), inner: VariantItem(Variant { kind: self.kind.clean(cx), }), @@ -2083,7 +2083,7 @@ impl Clean for doctree::Typedef { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id.clone()), + def_id: cx.map.local_def_id(self.id.clone()), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: TypedefItem(Typedef { @@ -2134,7 +2134,7 @@ impl Clean for doctree::Static { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: StaticItem(Static { @@ -2158,7 +2158,7 @@ impl Clean for doctree::Constant { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: ConstantItem(Constant { @@ -2232,7 +2232,7 @@ impl Clean> for doctree::Impl { name: None, attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), stability: self.stab.clean(cx), inner: ImplItem(Impl { @@ -2314,7 +2314,7 @@ impl Clean for doctree::DefaultImpl { name: None, attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: Some(hir::Public), stability: None, inner: DefaultImplItem(DefaultImpl { @@ -2331,7 +2331,7 @@ impl Clean for doctree::ExternCrate { name: None, attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(0), + def_id: cx.map.local_def_id(0), visibility: self.vis.clean(cx), stability: None, inner: ExternCrateItem(self.name.clean(cx), self.path.clone()) @@ -2396,7 +2396,7 @@ impl Clean> for doctree::Import { name: None, attrs: self.attrs.clean(cx), source: self.whence.clean(cx), - def_id: DefId::local(0), + def_id: cx.map.local_def_id(0), visibility: self.vis.clean(cx), stability: None, inner: ImportItem(inner) @@ -2482,9 +2482,9 @@ impl Clean for hir::ForeignItem { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx), source: self.span.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), visibility: self.vis.clean(cx), - stability: get_stability(cx, DefId::local(self.id)), + stability: get_stability(cx, cx.map.local_def_id(self.id)), inner: inner, } } @@ -2662,7 +2662,7 @@ impl Clean for doctree::Macro { source: self.whence.clean(cx), visibility: hir::Public.clean(cx), stability: self.stab.clean(cx), - def_id: DefId::local(self.id), + def_id: cx.map.local_def_id(self.id), inner: MacroItem(Macro { source: self.whence.to_src(cx), imported_from: self.imported_from.clean(cx), diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index d7238c827ab57..8bc832a68dbd7 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -19,7 +19,6 @@ use rustc::lint; use rustc_trans::back::link; use rustc_resolve as resolve; use rustc_front::lowering::lower_crate; -use rustc_front::hir; use syntax::{ast, codemap, diagnostic}; use syntax::feature_gate::UnstableFeatures; @@ -44,7 +43,7 @@ pub type ExternalPaths = RefCell, clean::TypeKind)>>>; pub struct DocContext<'a, 'tcx: 'a> { - pub krate: &'tcx hir::Crate, + pub map: &'a hir_map::Map<'tcx>, pub maybe_typed: MaybeTyped<'a, 'tcx>, pub input: Input, pub external_paths: ExternalPaths, @@ -148,7 +147,7 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec, externs: Externs, let ty::CrateAnalysis { exported_items, public_items, .. } = analysis; let ctxt = DocContext { - krate: tcx.map.krate(), + map: &tcx.map, maybe_typed: Typed(tcx), input: input, external_traits: RefCell::new(Some(HashMap::new())), @@ -158,7 +157,7 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec, externs: Externs, populated_crate_impls: RefCell::new(HashSet::new()), deref_trait_did: Cell::new(None), }; - debug!("crate: {:?}", ctxt.krate); + debug!("crate: {:?}", ctxt.map.krate()); let mut analysis = CrateAnalysis { exported_items: exported_items, @@ -171,7 +170,7 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec, externs: Externs, let krate = { let mut v = RustdocVisitor::new(&ctxt, Some(&analysis)); - v.visit(ctxt.krate); + v.visit(ctxt.map.krate()); v.clean(&ctxt) }; diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 509e6c7df7790..c392e75ebf91a 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -214,7 +214,7 @@ pub struct Cache { // then the fully qualified name of the structure isn't presented in `paths` // yet when its implementation methods are being indexed. Caches such methods // and their parent id here and indexes them at the end of crate parsing. - orphan_methods: Vec<(ast::NodeId, clean::Item)>, + orphan_methods: Vec<(DefId, clean::Item)>, } /// Helper struct to render all source code to HTML pages @@ -460,8 +460,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::Result { // Attach all orphan methods to the type's definition if the type // has since been learned. - for &(pid, ref item) in orphan_methods { - let did = DefId::local(pid); + for &(did, ref item) in orphan_methods { match paths.get(&did) { Some(&(ref fqp, _)) => { // Needed to determine `self` type. @@ -969,7 +968,7 @@ impl DocFolder for Cache { if parent.is_local() { // We have a parent, but we don't know where they're // defined yet. Wait for later to index this item. - self.orphan_methods.push((parent.node, item.clone())) + self.orphan_methods.push((parent, item.clone())) } } _ => {} @@ -1034,7 +1033,7 @@ impl DocFolder for Cache { ref t => { match t.primitive_type() { Some(prim) => { - let did = DefId::local(prim.to_node_id()); + let did = DefId::xxx_local(prim.to_node_id()); // TODO self.parent_stack.push(did); true } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 2f47353fee7b2..387e1a8cc0727 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -22,6 +22,7 @@ use std::sync::{Arc, Mutex}; use testing; use rustc_lint; +use rustc::front::map as hir_map; use rustc::session::{self, config}; use rustc::session::config::get_unstable_features_setting; use rustc::session::search_paths::{SearchPaths, PathKind}; @@ -86,8 +87,11 @@ pub fn run(input: &str, let opts = scrape_test_config(&krate); + let mut forest = hir_map::Forest::new(krate); + let map = hir_map::map_crate(&mut forest); + let ctx = core::DocContext { - krate: &krate, + map: &map, maybe_typed: core::NotTyped(sess), input: input, external_paths: RefCell::new(Some(HashMap::new())), @@ -99,7 +103,7 @@ pub fn run(input: &str, }; let mut v = RustdocVisitor::new(&ctx, None); - v.visit(ctx.krate); + v.visit(ctx.map.krate()); let mut krate = v.clean(&ctx); match crate_name { Some(name) => krate.name = name, diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index d818115567770..f9c8f2a0b8dff 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -21,7 +21,6 @@ use syntax::attr::AttrMetaMethods; use syntax::codemap::Span; use rustc::front::map as hir_map; -use rustc::middle::def_id::DefId; use rustc::middle::stability; use rustc_front::hir; @@ -64,7 +63,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { fn stability(&self, id: ast::NodeId) -> Option { self.cx.tcx_opt().and_then( - |tcx| stability::lookup(tcx, DefId::local(id)).map(|x| x.clone())) + |tcx| stability::lookup(tcx, self.cx.map.local_def_id(id)).map(|x| x.clone())) } pub fn visit(&mut self, krate: &hir::Crate) { From aa40a1cad0f359bfc799545e70bb5c7c9e72ba93 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 3 Sep 2015 20:36:53 -0400 Subject: [PATCH 04/17] change creepy case to call span_bug instead of doing something clearly wrong --- src/librustc/middle/const_eval.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 4894a78f1acb4..bde81090aa01e 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -91,11 +91,11 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, let expr_id = match csearch::maybe_get_item_ast(tcx, enum_def, Box::new(|a, b, c, d| astencode::decode_inlined_item(a, b, c, d))) { csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => match item.node { - hir::ItemEnum(hir::EnumDef { ref variants }, _) => { - // NOTE this doesn't do the right thing, it compares inlined - // NodeId's to the original variant_def's NodeId, but they - // come from different crates, so they will likely never match. - variant_expr(&variants[..], variant_def.node).map(|e| e.id) + hir::ItemEnum(hir::EnumDef { .. }, _) => { + tcx.sess.span_bug( + item.span, + &format!("cross-crate enum discr constant with enum {:?} variant {:?}", + enum_def, variant_def)); } _ => None }, From 5600c6282e699ad77d0303456fa068aa649b7007 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 4 Sep 2015 13:52:28 -0400 Subject: [PATCH 05/17] move direct accesses of `node` to go through `as_local_node_id`, unless they are being used as an opaque "position identifier" --- src/librustc/front/map/mod.rs | 14 ++- src/librustc/metadata/csearch.rs | 74 +++++++------- src/librustc/metadata/decoder.rs | 50 +++++----- src/librustc/metadata/encoder.rs | 73 +++++++++----- src/librustc/metadata/tydecode.rs | 8 +- src/librustc/metadata/tyencode.rs | 2 +- src/librustc/middle/astencode.rs | 6 +- src/librustc/middle/check_static_recursion.rs | 56 ++++++----- src/librustc/middle/const_eval.rs | 34 ++++--- src/librustc/middle/dead.rs | 59 +++++++----- src/librustc/middle/def_id.rs | 12 +-- src/librustc/middle/lang_items.rs | 2 +- src/librustc/middle/pat_util.rs | 4 +- src/librustc/middle/reachable.rs | 59 +++++------- src/librustc/middle/stability.rs | 2 +- src/librustc/middle/ty/error.rs | 20 ++-- src/librustc/middle/ty/mod.rs | 30 +++--- src/librustc/middle/ty/sty.rs | 2 +- src/librustc/middle/ty/util.rs | 2 +- src/librustc/util/ppaux.rs | 20 ++-- src/librustc_borrowck/borrowck/fragments.rs | 3 +- src/librustc_driver/test.rs | 2 +- src/librustc_lint/builtin.rs | 39 +++++--- src/librustc_lint/unused.rs | 4 +- src/librustc_mir/tcx/expr.rs | 2 +- src/librustc_privacy/lib.rs | 96 ++++++++++++------- src/librustc_resolve/build_reduced_graph.rs | 4 +- src/librustc_resolve/lib.rs | 18 ++-- src/librustc_resolve/record_exports.rs | 6 +- src/librustc_trans/save/mod.rs | 43 ++++----- src/librustc_trans/save/recorder.rs | 20 ++-- src/librustc_trans/trans/base.rs | 18 ++-- src/librustc_trans/trans/callee.rs | 20 ++-- src/librustc_trans/trans/closure.rs | 17 ++-- src/librustc_trans/trans/consts.rs | 7 +- .../trans/debuginfo/metadata.rs | 6 +- src/librustc_trans/trans/debuginfo/utils.rs | 9 +- src/librustc_trans/trans/expr.rs | 4 +- src/librustc_trans/trans/inline.rs | 2 +- src/librustc_trans/trans/monomorphize.rs | 25 ++--- src/librustc_typeck/astconv.rs | 22 ++--- src/librustc_typeck/check/compare_method.rs | 8 +- src/librustc_typeck/check/dropck.rs | 14 +-- src/librustc_typeck/check/method/suggest.rs | 10 +- src/librustc_typeck/check/mod.rs | 7 +- src/librustc_typeck/check/upvar.rs | 10 +- src/librustc_typeck/check/writeback.rs | 4 +- src/librustc_typeck/coherence/mod.rs | 45 ++++----- src/librustc_typeck/coherence/overlap.rs | 6 +- src/librustc_typeck/collect.rs | 93 +++++++++--------- src/librustc_typeck/variance.rs | 17 ++-- src/librustdoc/clean/mod.rs | 11 +-- src/librustdoc/core.rs | 18 +++- src/librustdoc/html/format.rs | 2 +- src/librustdoc/html/render.rs | 27 +++--- src/librustdoc/passes.rs | 39 ++++---- src/librustdoc/visit_ast.rs | 12 ++- 57 files changed, 652 insertions(+), 567 deletions(-) diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index 8d8932552b7d4..b8d96cd3ba72b 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -274,7 +274,7 @@ impl<'ast> Map<'ast> { pub fn as_local_node_id(&self, def_id: DefId) -> Option { if def_id.krate == LOCAL_CRATE { - Some(def_id.node) + Some(def_id.xxx_node) } else { None } @@ -301,6 +301,10 @@ impl<'ast> Map<'ast> { } } + pub fn get_if_local(&self, id: DefId) -> Option> { + self.as_local_node_id(id).map(|id| self.get(id)) + } + /// Retrieve the Node corresponding to `id`, returning None if /// cannot be found. pub fn find(&self, id: NodeId) -> Option> { @@ -609,9 +613,13 @@ impl<'ast> Map<'ast> { .unwrap_or_else(|| panic!("AstMap.span: could not find span for id {:?}", id)) } + pub fn span_if_local(&self, id: DefId) -> Option { + self.as_local_node_id(id).map(|id| self.span(id)) + } + pub fn def_id_span(&self, def_id: DefId, fallback: Span) -> Span { - if def_id.is_local() { - self.opt_span(def_id.node).unwrap_or(fallback) + if let Some(node_id) = self.as_local_node_id(def_id) { + self.opt_span(node_id).unwrap_or(fallback) } else { fallback } diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 88d73b3feb390..70a969e4d8221 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -33,7 +33,7 @@ pub struct MethodInfo { pub fn get_symbol(cstore: &cstore::CStore, def: DefId) -> String { let cdata = cstore.get_crate_data(def.krate); - decoder::get_symbol(&cdata, def.node) + decoder::get_symbol(&cdata, def.xxx_node) } /// Iterates over all the language items in the given crate. @@ -59,7 +59,7 @@ pub fn each_child_of_item(cstore: &cstore::CStore, }; decoder::each_child_of_item(cstore.intr.clone(), &*crate_data, - def_id.node, + def_id.xxx_node, get_crate_data, callback) } @@ -83,7 +83,7 @@ pub fn each_top_level_item_of_crate(cstore: &cstore::CStore, pub fn get_item_path(tcx: &ty::ctxt, def: DefId) -> Vec { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - let path = decoder::get_item_path(&*cdata, def.node); + let path = decoder::get_item_path(&*cdata, def.xxx_node); cdata.with_local_path(|cpath| { let mut r = Vec::with_capacity(cpath.len() + path.len()); @@ -96,7 +96,7 @@ pub fn get_item_path(tcx: &ty::ctxt, def: DefId) -> Vec { pub fn get_item_name(tcx: &ty::ctxt, def: DefId) -> ast::Name { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_item_name(&cstore.intr, &cdata, def.node) + decoder::get_item_name(&cstore.intr, &cdata, def.xxx_node) } pub enum FoundAst<'ast> { @@ -113,14 +113,14 @@ pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId, -> FoundAst<'tcx> { 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) + decoder::maybe_get_item_ast(&*cdata, tcx, def.xxx_node, decode_inlined_item) } /// Returns information about the given implementation. pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: DefId) -> Vec { let cdata = cstore.get_crate_data(impl_def_id.krate); - decoder::get_impl_items(&*cdata, impl_def_id.node) + decoder::get_impl_items(&*cdata, impl_def_id.xxx_node) } pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) @@ -128,7 +128,7 @@ pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) let cdata = tcx.sess.cstore.get_crate_data(def.krate); decoder::get_impl_or_trait_item(tcx.sess.cstore.intr.clone(), &*cdata, - def.node, + def.xxx_node, tcx) } @@ -136,24 +136,24 @@ pub fn get_trait_name(cstore: &cstore::CStore, def: DefId) -> ast::Name { let cdata = cstore.get_crate_data(def.krate); decoder::get_trait_name(cstore.intr.clone(), &*cdata, - def.node) + def.xxx_node) } pub fn is_static_method(cstore: &cstore::CStore, def: DefId) -> bool { let cdata = cstore.get_crate_data(def.krate); - decoder::is_static_method(&*cdata, def.node) + decoder::is_static_method(&*cdata, def.xxx_node) } pub fn get_trait_item_def_ids(cstore: &cstore::CStore, def: DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_trait_item_def_ids(&*cdata, def.node) + decoder::get_trait_item_def_ids(&*cdata, def.xxx_node) } pub fn get_item_variances(cstore: &cstore::CStore, def: DefId) -> ty::ItemVariances { let cdata = cstore.get_crate_data(def.krate); - decoder::get_item_variances(&*cdata, def.node) + decoder::get_item_variances(&*cdata, def.xxx_node) } pub fn get_provided_trait_methods<'tcx>(tcx: &ty::ctxt<'tcx>, @@ -161,39 +161,39 @@ pub fn get_provided_trait_methods<'tcx>(tcx: &ty::ctxt<'tcx>, -> Vec>> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.node, tcx) + decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.xxx_node, tcx) } pub fn get_associated_consts<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> Vec>> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_associated_consts(cstore.intr.clone(), &*cdata, def.node, tcx) + decoder::get_associated_consts(cstore.intr.clone(), &*cdata, def.xxx_node, tcx) } pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: DefId) -> Option { let cdata = cstore.get_crate_data(def.krate); - decoder::get_type_name_if_impl(&*cdata, def.node) + decoder::get_type_name_if_impl(&*cdata, def.xxx_node) } pub fn get_methods_if_impl(cstore: &cstore::CStore, def: DefId) -> Option > { let cdata = cstore.get_crate_data(def.krate); - decoder::get_methods_if_impl(cstore.intr.clone(), &*cdata, def.node) + decoder::get_methods_if_impl(cstore.intr.clone(), &*cdata, def.xxx_node) } pub fn get_item_attrs(cstore: &cstore::CStore, def_id: DefId) -> Vec { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_item_attrs(&*cdata, def_id.node) + decoder::get_item_attrs(&*cdata, def_id.xxx_node) } pub fn get_struct_field_names(cstore: &cstore::CStore, def: DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_struct_field_names(&cstore.intr, &*cdata, def.node) + decoder::get_struct_field_names(&cstore.intr, &*cdata, def.xxx_node) } pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: DefId) -> FnvHashMap(tcx: &ty::ctxt<'tcx>, -> ty::TypeScheme<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_type(&*cdata, def.node, tcx) + decoder::get_type(&*cdata, def.xxx_node, tcx) } pub fn get_trait_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_trait_def(&*cdata, def.node, tcx) + decoder::get_trait_def(&*cdata, def.xxx_node, tcx) } pub fn get_adt_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_adt_def(&cstore.intr, &*cdata, def.node, tcx) + decoder::get_adt_def(&cstore.intr, &*cdata, def.xxx_node, tcx) } pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) @@ -227,7 +227,7 @@ pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_predicates(&*cdata, def.node, tcx) + decoder::get_predicates(&*cdata, def.xxx_node, tcx) } pub fn get_super_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) @@ -235,7 +235,7 @@ pub fn get_super_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_super_predicates(&*cdata, def.node, tcx) + decoder::get_super_predicates(&*cdata, def.xxx_node, tcx) } pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>, @@ -244,7 +244,7 @@ pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>, { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_polarity(&*cdata, def.node) + decoder::get_impl_polarity(&*cdata, def.xxx_node) } pub fn get_custom_coerce_unsized_kind<'tcx>( @@ -254,7 +254,7 @@ pub fn get_custom_coerce_unsized_kind<'tcx>( { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_custom_coerce_unsized_kind(&*cdata, def.node) + decoder::get_custom_coerce_unsized_kind(&*cdata, def.xxx_node) } // Given a def_id for an impl, return the trait it implements, @@ -264,7 +264,7 @@ pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>, -> Option> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_trait(&*cdata, def.node, tcx) + decoder::get_impl_trait(&*cdata, def.xxx_node, tcx) } pub fn get_native_libraries(cstore: &cstore::CStore, crate_num: ast::CrateNum) @@ -279,7 +279,7 @@ pub fn each_inherent_implementation_for_type(cstore: &cstore::CStore, F: FnMut(DefId), { let cdata = cstore.get_crate_data(def_id.krate); - decoder::each_inherent_implementation_for_type(&*cdata, def_id.node, callback) + decoder::each_inherent_implementation_for_type(&*cdata, def_id.xxx_node, callback) } pub fn each_implementation_for_trait(cstore: &cstore::CStore, @@ -300,7 +300,7 @@ pub fn get_trait_of_item(cstore: &cstore::CStore, tcx: &ty::ctxt) -> Option { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_trait_of_item(&*cdata, def_id.node, tcx) + decoder::get_trait_of_item(&*cdata, def_id.xxx_node, tcx) } pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, @@ -308,7 +308,7 @@ pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, -> Option { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.node) + decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.xxx_node) } pub fn get_dylib_dependency_formats(cstore: &cstore::CStore, @@ -330,7 +330,7 @@ pub fn get_method_arg_names(cstore: &cstore::CStore, did: DefId) -> Vec { let cdata = cstore.get_crate_data(did.krate); - decoder::get_method_arg_names(&*cdata, did.node) + decoder::get_method_arg_names(&*cdata, did.xxx_node) } pub fn get_reachable_ids(cstore: &cstore::CStore, cnum: ast::CrateNum) @@ -342,24 +342,24 @@ pub fn get_reachable_ids(cstore: &cstore::CStore, cnum: ast::CrateNum) pub fn is_typedef(cstore: &cstore::CStore, did: DefId) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_typedef(&*cdata, did.node) + decoder::is_typedef(&*cdata, did.xxx_node) } pub fn is_const_fn(cstore: &cstore::CStore, did: DefId) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_const_fn(&*cdata, did.node) + decoder::is_const_fn(&*cdata, did.xxx_node) } pub fn is_impl(cstore: &cstore::CStore, did: DefId) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_impl(&*cdata, did.node) + decoder::is_impl(&*cdata, did.xxx_node) } pub fn get_stability(cstore: &cstore::CStore, def: DefId) -> Option { let cdata = cstore.get_crate_data(def.krate); - decoder::get_stability(&*cdata, def.node) + decoder::get_stability(&*cdata, def.xxx_node) } pub fn is_staged_api(cstore: &cstore::CStore, krate: ast::CrateNum) -> bool { @@ -369,21 +369,21 @@ pub fn is_staged_api(cstore: &cstore::CStore, krate: ast::CrateNum) -> bool { pub fn get_repr_attrs(cstore: &cstore::CStore, def: DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_repr_attrs(&*cdata, def.node) + decoder::get_repr_attrs(&*cdata, def.xxx_node) } pub fn is_defaulted_trait(cstore: &cstore::CStore, trait_def_id: DefId) -> bool { let cdata = cstore.get_crate_data(trait_def_id.krate); - decoder::is_defaulted_trait(&*cdata, trait_def_id.node) + decoder::is_defaulted_trait(&*cdata, trait_def_id.xxx_node) } pub fn is_default_impl(cstore: &cstore::CStore, impl_did: DefId) -> bool { let cdata = cstore.get_crate_data(impl_did.krate); - decoder::is_default_impl(&*cdata, impl_did.node) + decoder::is_default_impl(&*cdata, impl_did.xxx_node) } pub fn is_extern_fn(cstore: &cstore::CStore, did: DefId, tcx: &ty::ctxt) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_extern_fn(&*cdata, did.node, tcx) + decoder::is_extern_fn(&*cdata, did.xxx_node, tcx) } diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 2e7a49b25fe37..54a815b454aac 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -170,7 +170,7 @@ fn item_symbol(item: rbml::Doc) -> String { fn translated_def_id(cdata: Cmd, d: rbml::Doc) -> DefId { let id = reader::doc_as_u64(d); - let def_id = DefId { krate: (id >> 32) as u32, node: id as u32 }; + let def_id = DefId { krate: (id >> 32) as u32, xxx_node: id as u32 }; translate_def_id(cdata, def_id) } @@ -378,7 +378,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, let mut disr_val = 0; reader::tagged_docs(doc, tag_items_data_item_variant).map(|p| { let did = translated_def_id(cdata, p); - let item = cdata.lookup_item(did.node); + let item = cdata.lookup_item(did.xxx_node); if let Some(disr) = variant_disr_val(item) { disr_val = disr; @@ -428,7 +428,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, } let doc = cdata.lookup_item(item_id); - let did = DefId { krate: cdata.cnum, node: item_id }; + let did = DefId { krate: cdata.cnum, xxx_node: item_id }; let (kind, variants) = match item_family(doc) { Enum => (ty::AdtKind::Enum, get_enum_variants(intr, cdata, doc, tcx)), @@ -448,7 +448,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, // from the ctor. debug!("evaluating the ctor-type of {:?}", variant.name); - let ctor_ty = get_type(cdata, variant.did.node, tcx).ty; + let ctor_ty = get_type(cdata, variant.did.xxx_node, tcx).ty; debug!("evaluating the ctor-type of {:?}.. {:?}", variant.name, ctor_ty); @@ -468,7 +468,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, } else { for field in &variant.fields { debug!("evaluating the type of {:?}::{:?}", variant.name, field.name); - let ty = get_type(cdata, field.did.node, tcx).ty; + let ty = get_type(cdata, field.did.xxx_node, tcx).ty; field.fulfill_ty(ty); debug!("evaluating the type of {:?}::{:?}: {:?}", variant.name, field.name, ty); @@ -501,7 +501,7 @@ pub fn get_type<'tcx>(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt<'tcx>) -> ty::TypeScheme<'tcx> { let item_doc = cdata.lookup_item(id); - let t = item_type(DefId { krate: cdata.cnum, node: id }, item_doc, tcx, + let t = item_type(DefId { krate: cdata.cnum, xxx_node: id }, item_doc, tcx, cdata); let generics = doc_generics(item_doc, tcx, cdata, tag_item_generics); ty::TypeScheme { @@ -634,7 +634,7 @@ fn each_child_of_item_or_crate(intr: Rc, }; // Get the item. - match crate_data.get_item(child_def_id.node) { + match crate_data.get_item(child_def_id.xxx_node) { None => {} Some(child_item_doc) => { // Hand off the item to the callback. @@ -652,12 +652,12 @@ fn each_child_of_item_or_crate(intr: Rc, for inherent_impl_def_id_doc in reader::tagged_docs(item_doc, tag_items_data_item_inherent_impl) { let inherent_impl_def_id = item_def_id(inherent_impl_def_id_doc, cdata); - if let Some(inherent_impl_doc) = cdata.get_item(inherent_impl_def_id.node) { + if let Some(inherent_impl_doc) = cdata.get_item(inherent_impl_def_id.xxx_node) { for impl_item_def_id_doc in reader::tagged_docs(inherent_impl_doc, tag_item_impl_item) { let impl_item_def_id = item_def_id(impl_item_def_id_doc, cdata); - if let Some(impl_method_doc) = cdata.get_item(impl_item_def_id.node) { + if let Some(impl_method_doc) = cdata.get_item(impl_item_def_id.xxx_node) { if let StaticMethod = item_family(impl_method_doc) { // Hand off the static method to the callback. let static_method_name = item_name(&*intr, impl_method_doc); @@ -693,7 +693,7 @@ fn each_child_of_item_or_crate(intr: Rc, }; // Get the item. - if let Some(child_item_doc) = crate_data.get_item(child_def_id.node) { + if let Some(child_item_doc) = crate_data.get_item(child_def_id.xxx_node) { // Hand off the item to the callback. let def_like = item_to_def_like(crate_data, child_item_doc, child_def_id); // These items have a public visibility because they're part of @@ -771,7 +771,7 @@ pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: ast::NodeI Err(path) => { match item_parent_item(cdata, item_doc) { Some(did) => { - let parent_item = cdata.lookup_item(did.node); + let parent_item = cdata.lookup_item(did.xxx_node); match decode_inlined_item(cdata, tcx, path, parent_item) { Ok(ii) => csearch::FoundAst::FoundParent(did, ii), Err(_) => csearch::FoundAst::NotFound @@ -852,7 +852,7 @@ pub fn get_impl_or_trait_item<'tcx>(intr: Rc, let def_id = item_def_id(item_doc, cdata); let container_id = item_require_parent_item(cdata, item_doc); - let container_doc = cdata.lookup_item(container_id.node); + let container_doc = cdata.lookup_item(container_id.xxx_node); let container = match item_family(container_doc) { Trait => TraitContainer(container_id), _ => ImplContainer(container_id), @@ -932,12 +932,12 @@ pub fn get_provided_trait_methods<'tcx>(intr: Rc, reader::tagged_docs(item, tag_item_trait_item).filter_map(|mth_id| { let did = item_def_id(mth_id, cdata); - let mth = cdata.lookup_item(did.node); + let mth = cdata.lookup_item(did.xxx_node); if item_sort(mth) == Some('p') { let trait_item = get_impl_or_trait_item(intr.clone(), cdata, - did.node, + did.xxx_node, tcx); if let ty::MethodTraitItem(ref method) = trait_item { Some((*method).clone()) @@ -960,13 +960,13 @@ pub fn get_associated_consts<'tcx>(intr: Rc, [tag_item_trait_item, tag_item_impl_item].iter().flat_map(|&tag| { reader::tagged_docs(item, tag).filter_map(|ac_id| { let did = item_def_id(ac_id, cdata); - let ac_doc = cdata.lookup_item(did.node); + let ac_doc = cdata.lookup_item(did.xxx_node); match item_sort(ac_doc) { Some('C') | Some('c') => { let trait_item = get_impl_or_trait_item(intr.clone(), cdata, - did.node, + did.xxx_node, tcx); if let ty::ConstTraitItem(ref ac) = trait_item { Some((*ac).clone()) @@ -1011,7 +1011,7 @@ pub fn get_methods_if_impl(intr: Rc, let mut impl_methods = Vec::new(); for impl_method_id in impl_method_ids { - let impl_method_doc = cdata.lookup_item(impl_method_id.node); + let impl_method_doc = cdata.lookup_item(impl_method_id.xxx_node); let family = item_family(impl_method_doc); match family { StaticMethod | Method => { @@ -1047,7 +1047,7 @@ pub fn get_item_attrs(cdata: Cmd, // we assume that someone passing in a tuple struct ctor is actually wanting to // look at the definition let node_id = get_tuple_struct_definition_if_ctor(cdata, orig_node_id); - let node_id = node_id.map(|x| x.node).unwrap_or(orig_node_id); + let node_id = node_id.map(|x| x.xxx_node).unwrap_or(orig_node_id); let item = cdata.lookup_item(node_id); get_attributes(item) } @@ -1228,14 +1228,14 @@ pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Write) -> io::Result<()> // crate to the correct local crate number. pub fn translate_def_id(cdata: Cmd, did: DefId) -> DefId { if did.is_local() { - return DefId { krate: cdata.cnum, node: did.node }; + return DefId { krate: cdata.cnum, xxx_node: did.xxx_node }; } match cdata.cnum_map.borrow().get(&did.krate) { Some(&n) => { DefId { krate: n, - node: did.node, + xxx_node: did.xxx_node, } } None => panic!("didn't find a crate in the cnum_map") @@ -1246,12 +1246,12 @@ pub fn translate_def_id(cdata: Cmd, did: DefId) -> DefId { // for an external crate. fn reverse_translate_def_id(cdata: Cmd, did: DefId) -> Option { if did.krate == cdata.cnum { - return Some(DefId { krate: LOCAL_CRATE, node: did.node }); + return Some(DefId { krate: LOCAL_CRATE, xxx_node: did.xxx_node }); } for (&local, &global) in cdata.cnum_map.borrow().iter() { if global == did.krate { - return Some(DefId { krate: local, node: did.node }); + return Some(DefId { krate: local, xxx_node: did.xxx_node }); } } @@ -1277,7 +1277,7 @@ pub fn each_implementation_for_trait(cdata: Cmd, F: FnMut(DefId), { if cdata.cnum == def_id.krate { - let item_doc = cdata.lookup_item(def_id.node); + let item_doc = cdata.lookup_item(def_id.xxx_node); for impl_doc in reader::tagged_docs(item_doc, tag_items_data_item_extension_impl) { callback(item_def_id(impl_doc, cdata)); } @@ -1306,7 +1306,7 @@ pub fn get_trait_of_item(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt) None => return None, Some(item_id) => item_id, }; - let parent_item_doc = cdata.lookup_item(parent_item_id.node); + let parent_item_doc = cdata.lookup_item(parent_item_id.xxx_node); match item_family(parent_item_doc) { Trait => Some(item_def_id(parent_item_doc, cdata)), Impl | DefaultImpl => { @@ -1404,7 +1404,7 @@ pub fn get_reachable_ids(cdata: Cmd) -> Vec { reader::tagged_docs(items, tag_reachable_id).map(|doc| { DefId { krate: cdata.cnum, - node: reader::doc_as_u32(doc), + xxx_node: reader::doc_as_u32(doc), } }).collect() } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index b67da4baf5ab0..14e5e8b41ffbb 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -75,6 +75,12 @@ pub struct EncodeContext<'a, 'tcx: 'a> { pub reachable: &'a NodeSet, } +impl<'a, 'tcx> EncodeContext<'a,'tcx> { + fn local_id(&self, def_id: DefId) -> NodeId { + self.tcx.map.as_local_node_id(def_id).unwrap() + } +} + fn encode_name(rbml_w: &mut Encoder, name: Name) { rbml_w.wr_tagged_str(tag_paths_data_name, &name.as_str()); } @@ -109,11 +115,11 @@ fn encode_family(rbml_w: &mut Encoder, c: char) { } pub fn def_to_u64(did: DefId) -> u64 { - (did.krate as u64) << 32 | (did.node as u64) + (did.krate as u64) << 32 | (did.xxx_node as u64) } pub fn def_to_string(did: DefId) -> String { - format!("{}:{}", did.krate, did.node) + format!("{}:{}", did.krate, did.xxx_node) } fn encode_item_variances(rbml_w: &mut Encoder, @@ -281,7 +287,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let def = ecx.tcx.lookup_adt_def(ecx.tcx.map.local_def_id(id)); for variant in &def.variants { let vid = variant.did; - assert!(vid.is_local()); + let variant_node_id = ecx.local_id(vid); if let ty::VariantKind::Dict = variant.kind() { // tuple-like enum variant fields aren't really items so @@ -292,7 +298,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, } index.push(IndexEntry { - node: vid.node, + node: vid.xxx_node, pos: rbml_w.mark_stable_position(), }); rbml_w.start_tag(tag_items_data_item); @@ -319,9 +325,9 @@ fn encode_enum_variant_info(ecx: &EncodeContext, encode_disr_val(ecx, rbml_w, specified_disr_val); disr_val = specified_disr_val; } - encode_bounds_and_type_for_item(rbml_w, ecx, vid.node); + encode_bounds_and_type_for_item(rbml_w, ecx, variant_node_id); - ecx.tcx.map.with_path(vid.node, |path| encode_path(rbml_w, path)); + ecx.tcx.map.with_path(variant_node_id, |path| encode_path(rbml_w, path)); rbml_w.end_tag(); disr_val = disr_val.wrapping_add(1); } @@ -405,8 +411,21 @@ fn encode_reexported_static_methods(ecx: &EncodeContext, rbml_w: &mut Encoder, mod_path: PathElems, exp: &def::Export) { - if let Some(ast_map::NodeItem(item)) = ecx.tcx.map.find(exp.def_id.node) { - let path_differs = ecx.tcx.map.with_path(exp.def_id.node, |path| { + let exp_node_id = if let Some(n) = ecx.tcx.map.as_local_node_id(exp.def_id) { + n + } else { + // Before the refactor that introducd `as_local_node_id`, we + // were just extracting the node and checking into the + // ast-map. Since the node might have been from another crate, + // this was a tenuous thing to do at best. Anyway, I'm not + // 100% clear on why it's ok to ignore things from other + // crates, but it seems to be what we were doing pre-refactor. + // -nmatsakis + return; + }; + + if let Some(ast_map::NodeItem(item)) = ecx.tcx.map.find(exp_node_id) { + let path_differs = ecx.tcx.map.with_path(exp_node_id, |path| { let (mut a, mut b) = (path, mod_path.clone()); loop { match (a.next(), b.next()) { @@ -476,11 +495,10 @@ fn encode_reexports(ecx: &EncodeContext, Some(exports) => { debug!("(encoding info for module) found reexports for {}", id); for exp in exports { - debug!("(encoding info for module) reexport '{}' ({}/{}) for \ + debug!("(encoding info for module) reexport '{}' ({:?}) for \ {}", exp.name, - exp.def_id.krate, - exp.def_id.node, + exp.def_id, id); rbml_w.start_tag(tag_items_data_item_reexport); rbml_w.wr_tagged_u64(tag_items_data_item_reexport_def_id, @@ -615,7 +633,7 @@ fn encode_field<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, field: ty::FieldDef<'tcx>, global_index: &mut Vec) { let nm = field.name; - let id = field.did.node; + let id = ecx.local_id(field.did); let pos = rbml_w.mark_stable_position(); global_index.push(IndexEntry { @@ -792,7 +810,7 @@ fn encode_info_for_associated_const(ecx: &EncodeContext, encode_parent_item(rbml_w, ecx.tcx.map.local_def_id(parent_id)); encode_item_sort(rbml_w, 'C'); - encode_bounds_and_type_for_item(rbml_w, ecx, associated_const.def_id.local_id()); + encode_bounds_and_type_for_item(rbml_w, ecx, ecx.local_id(associated_const.def_id)); let stab = stability::lookup(ecx.tcx, associated_const.def_id); encode_stability(rbml_w, stab); @@ -831,7 +849,8 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, encode_stability(rbml_w, stab); // The type for methods gets encoded twice, which is unfortunate. - encode_bounds_and_type_for_item(rbml_w, ecx, m.def_id.local_id()); + let m_node_id = ecx.local_id(m.def_id); + encode_bounds_and_type_for_item(rbml_w, ecx, m_node_id); let elem = ast_map::PathName(m.name); encode_path(rbml_w, impl_path.chain(Some(elem))); @@ -850,7 +869,8 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, } encode_constness(rbml_w, sig.constness); if !any_types { - encode_symbol(ecx, rbml_w, m.def_id.node); + let m_id = ecx.local_id(m.def_id); + encode_symbol(ecx, rbml_w, m_id); } encode_method_argument_names(rbml_w, &sig.decl); } @@ -1166,7 +1186,7 @@ fn encode_info_for_item(ecx: &EncodeContext, match struct_def.ctor_id { Some(ctor_id) => { encode_info_for_struct_ctor(ecx, rbml_w, item.name, - ctor_id, index, def_id.node); + ctor_id, index, item.id); } None => {} } @@ -1253,7 +1273,7 @@ fn encode_info_for_item(ecx: &EncodeContext, }; index.push(IndexEntry { - node: trait_item_def_id.def_id().node, + node: trait_item_def_id.def_id().xxx_node, pos: rbml_w.mark_stable_position(), }); @@ -1344,7 +1364,7 @@ fn encode_info_for_item(ecx: &EncodeContext, assert_eq!(item_def_id.def_id().krate, LOCAL_CRATE); index.push(IndexEntry { - node: item_def_id.def_id().node, + node: item_def_id.def_id().xxx_node, pos: rbml_w.mark_stable_position(), }); @@ -1370,8 +1390,9 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_family(rbml_w, 'C'); - encode_bounds_and_type_for_item(rbml_w, ecx, - associated_const.def_id.local_id()); + encode_bounds_and_type_for_item(rbml_w, + ecx, + ecx.local_id(associated_const.def_id)); is_nonstatic_method = false; } @@ -1394,7 +1415,7 @@ fn encode_info_for_item(ecx: &EncodeContext, METHOD_FAMILY); } } - encode_bounds_and_type_for_item(rbml_w, ecx, method_def_id.local_id()); + encode_bounds_and_type_for_item(rbml_w, ecx, ecx.local_id(method_def_id)); is_nonstatic_method = method_ty.explicit_self != ty::StaticExplicitSelfCategory; @@ -1439,8 +1460,10 @@ fn encode_info_for_item(ecx: &EncodeContext, if is_nonstatic_method { // FIXME: I feel like there is something funny // going on. - encode_bounds_and_type_for_item(rbml_w, ecx, - item_def_id.def_id().local_id()); + encode_bounds_and_type_for_item( + rbml_w, + ecx, + ecx.local_id(item_def_id.def_id())); } if body.is_some() { @@ -1716,10 +1739,10 @@ fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { for (i, &def_id) in ecx.tcx.lang_items.items() { if let Some(id) = def_id { - if id.is_local() { + if let Some(id) = ecx.tcx.map.as_local_node_id(id) { rbml_w.start_tag(tag_lang_items_item); rbml_w.wr_tagged_u32(tag_lang_items_item_id, i as u32); - rbml_w.wr_tagged_u32(tag_lang_items_item_node_id, id.node as u32); + rbml_w.wr_tagged_u32(tag_lang_items_item_node_id, id as u32); rbml_w.end_tag(); } } diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 75afe11839ce8..f023049d78f61 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -209,10 +209,6 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { } 'B' => { assert_eq!(self.next(), '['); - // this is the wrong NodeId, but `param_id` is only accessed - // by the receiver-matching code in collect, which won't - // be going down this code path, and anyway I will kill it - // the moment wfcheck becomes the standard. let def_id = self.parse_def(NominalType); let space = self.parse_param_space(); assert_eq!(self.next(), '|'); @@ -220,7 +216,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { assert_eq!(self.next(), '|'); let name = token::intern(&self.parse_str(']')); ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: def_id, + def_id: def_id, space: space, index: index, name: name @@ -739,7 +735,7 @@ fn parse_defid(buf: &[u8]) -> DefId { None => panic!("internal error: parse_defid: id expected, found {:?}", def_part) }; - DefId { krate: crate_num, node: def_num } + DefId { krate: crate_num, xxx_node: def_num } } fn parse_unsafety(c: char) -> hir::Unsafety { diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index c085f0e582562..01e6e30b53f77 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -250,7 +250,7 @@ pub fn enc_region(w: &mut Encoder, cx: &ctxt, r: ty::Region) { } ty::ReEarlyBound(ref data) => { mywrite!(w, "B[{}|{}|{}|{}]", - (cx.ds)(data.param_id), + (cx.ds)(data.def_id), data.space.to_uint(), data.index, data.name); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index a137d295bd199..a06a6b2509af8 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -229,7 +229,7 @@ impl<'a, 'b, 'tcx> DecodeContext<'a, 'b, 'tcx> { /// refer to the current crate and to the new, inlined node-id. pub fn tr_intern_def_id(&self, did: DefId) -> DefId { assert_eq!(did.krate, LOCAL_CRATE); - DefId { krate: LOCAL_CRATE, node: self.tr_id(did.node) } + DefId { krate: LOCAL_CRATE, xxx_node: self.tr_id(did.xxx_node) } } /// Translates a `Span` from an extern crate to the corresponding `Span` @@ -951,7 +951,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } } - let lid = DefId { krate: LOCAL_CRATE, node: id }; + let lid = tcx.map.local_def_id(id); if let Some(type_scheme) = tcx.tcache.borrow().get(&lid) { rbml_w.tag(c::tag_table_tcache, |rbml_w| { rbml_w.id(id); @@ -1453,7 +1453,7 @@ fn decode_side_tables(dcx: &DecodeContext, } c::tag_table_tcache => { let type_scheme = val_dsr.read_type_scheme(dcx); - let lid = DefId { krate: LOCAL_CRATE, node: id }; + let lid = dcx.tcx.map.local_def_id(id); dcx.tcx.register_item_type(lid, type_scheme); } c::tag_table_param_defs => { diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs index 942d8313ec24e..acb66b8efe7eb 100644 --- a/src/librustc/middle/check_static_recursion.rs +++ b/src/librustc/middle/check_static_recursion.rs @@ -240,37 +240,43 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> { match self.def_map.borrow().get(&e.id).map(|d| d.base_def) { Some(DefStatic(def_id, _)) | Some(DefAssociatedConst(def_id)) | - Some(DefConst(def_id)) if def_id.is_local() => { - match self.ast_map.get(def_id.node) { - ast_map::NodeItem(item) => - self.visit_item(item), - ast_map::NodeTraitItem(item) => - self.visit_trait_item(item), - ast_map::NodeImplItem(item) => - self.visit_impl_item(item), - ast_map::NodeForeignItem(_) => {}, - _ => { - self.sess.span_bug( - e.span, - &format!("expected item, found {}", - self.ast_map.node_to_string(def_id.node))); - } + Some(DefConst(def_id)) => { + if let Some(node_id) = self.ast_map.as_local_node_id(def_id) { + match self.ast_map.get(node_id) { + ast_map::NodeItem(item) => + self.visit_item(item), + ast_map::NodeTraitItem(item) => + self.visit_trait_item(item), + ast_map::NodeImplItem(item) => + self.visit_impl_item(item), + ast_map::NodeForeignItem(_) => {}, + _ => { + self.sess.span_bug( + e.span, + &format!("expected item, found {}", + self.ast_map.node_to_string(node_id))); + } + } } } // For variants, we only want to check expressions that // affect the specific variant used, but we need to check // the whole enum definition to see what expression that // might be (if any). - Some(DefVariant(enum_id, variant_id, false)) if enum_id.is_local() => { - if let hir::ItemEnum(ref enum_def, ref generics) = - self.ast_map.expect_item(enum_id.local_id()).node { - self.populate_enum_discriminants(enum_def); - let variant = self.ast_map.expect_variant(variant_id.local_id()); - self.visit_variant(variant, generics); - } else { - self.sess.span_bug(e.span, - "`check_static_recursion` found \ - non-enum in DefVariant"); + Some(DefVariant(enum_id, variant_id, false)) => { + if let Some(enum_node_id) = self.ast_map.as_local_node_id(enum_id) { + if let hir::ItemEnum(ref enum_def, ref generics) = + self.ast_map.expect_item(enum_node_id).node + { + self.populate_enum_discriminants(enum_def); + let variant_id = self.ast_map.as_local_node_id(variant_id).unwrap(); + let variant = self.ast_map.expect_variant(variant_id); + self.visit_variant(variant, generics); + } else { + self.sess.span_bug(e.span, + "`check_static_recursion` found \ + non-enum in DefVariant"); + } } } _ => () diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index bde81090aa01e..00cfbf2dfe2c2 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -69,12 +69,13 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, None } - if enum_def.is_local() { - match tcx.map.find(enum_def.node) { + if let Some(enum_node_id) = tcx.map.as_local_node_id(enum_def) { + let variant_node_id = tcx.map.as_local_node_id(variant_def).unwrap(); + match tcx.map.find(enum_node_id) { None => None, Some(ast_map::NodeItem(it)) => match it.node { hir::ItemEnum(hir::EnumDef { ref variants }, _) => { - variant_expr(&variants[..], variant_def.node) + variant_expr(&variants[..], variant_node_id) } _ => None }, @@ -88,8 +89,11 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, } None => {} } - let expr_id = match csearch::maybe_get_item_ast(tcx, enum_def, - Box::new(|a, b, c, d| astencode::decode_inlined_item(a, b, c, d))) { + let expr_id = match + csearch::maybe_get_item_ast( + tcx, enum_def, + Box::new(|a, b, c, d| astencode::decode_inlined_item(a, b, c, d))) + { csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => match item.node { hir::ItemEnum(hir::EnumDef { .. }, _) => { tcx.sess.span_bug( @@ -111,8 +115,8 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, def_id: DefId, maybe_ref_id: Option) -> Option<&'tcx Expr> { - if def_id.is_local() { - match tcx.map.find(def_id.node) { + if let Some(node_id) = tcx.map.as_local_node_id(def_id) { + match tcx.map.find(node_id) { None => None, Some(ast_map::NodeItem(it)) => match it.node { hir::ItemConst(_, ref const_expr) => { @@ -233,14 +237,14 @@ fn inline_const_fn_from_external_crate(tcx: &ty::ctxt, def_id: DefId) pub fn lookup_const_fn_by_id<'tcx>(tcx: &ty::ctxt<'tcx>, def_id: DefId) -> Option> { - let fn_id = if !def_id.is_local() { + let fn_id = if let Some(node_id) = tcx.map.as_local_node_id(def_id) { + node_id + } else { if let Some(fn_id) = inline_const_fn_from_external_crate(tcx, def_id) { fn_id } else { return None; } - } else { - def_id.node }; let fn_like = match FnLikeNode::from_node(tcx.map.get(fn_id)) { @@ -919,8 +923,8 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, let opt_def = tcx.def_map.borrow().get(&e.id).map(|d| d.full_def()); let (const_expr, const_ty) = match opt_def { Some(def::DefConst(def_id)) => { - if def_id.is_local() { - match tcx.map.find(def_id.node) { + if let Some(node_id) = tcx.map.as_local_node_id(def_id) { + match tcx.map.find(node_id) { Some(ast_map::NodeItem(it)) => match it.node { hir::ItemConst(ref ty, ref expr) => { (Some(&**expr), Some(&**ty)) @@ -934,9 +938,9 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, } } Some(def::DefAssociatedConst(def_id)) => { - if def_id.is_local() { + if let Some(node_id) = tcx.map.as_local_node_id(def_id) { match tcx.impl_or_trait_item(def_id).container() { - ty::TraitContainer(trait_id) => match tcx.map.find(def_id.node) { + ty::TraitContainer(trait_id) => match tcx.map.find(node_id) { Some(ast_map::NodeTraitItem(ti)) => match ti.node { hir::ConstTraitItem(ref ty, _) => { if let ExprTypeChecked = ty_hint { @@ -954,7 +958,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, }, _ => (None, None) }, - ty::ImplContainer(_) => match tcx.map.find(def_id.node) { + ty::ImplContainer(_) => match tcx.map.find(node_id) { Some(ast_map::NodeImplItem(ii)) => match ii.node { hir::ConstImplItem(ref ty, ref expr) => { (Some(&**expr), Some(&**ty)) diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 86dbbb578fff9..994311efe79c5 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -29,17 +29,15 @@ use syntax::attr::{self, AttrMetaMethods}; // explored. For example, if it's a live NodeItem that is a // function, then we should explore its block to check for codes that // may need to be marked as live. -fn should_explore(tcx: &ty::ctxt, def_id: DefId) -> bool { - if !def_id.is_local() { - return false; - } - - match tcx.map.find(def_id.node) { - Some(ast_map::NodeItem(..)) - | Some(ast_map::NodeImplItem(..)) - | Some(ast_map::NodeForeignItem(..)) - | Some(ast_map::NodeTraitItem(..)) => true, - _ => false +fn should_explore(tcx: &ty::ctxt, node_id: ast::NodeId) -> bool { + match tcx.map.find(node_id) { + Some(ast_map::NodeItem(..)) | + Some(ast_map::NodeImplItem(..)) | + Some(ast_map::NodeForeignItem(..)) | + Some(ast_map::NodeTraitItem(..)) => + true, + _ => + false } } @@ -50,7 +48,7 @@ struct MarkSymbolVisitor<'a, 'tcx: 'a> { struct_has_extern_repr: bool, ignore_non_const_paths: bool, inherited_pub_visibility: bool, - ignore_variant_stack: Vec, + ignore_variant_stack: Vec, } impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { @@ -68,10 +66,19 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } fn check_def_id(&mut self, def_id: DefId) { - if should_explore(self.tcx, def_id) { - self.worklist.push(def_id.node); + if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) { + if should_explore(self.tcx, node_id) { + self.worklist.push(node_id); + } + self.live_symbols.insert(node_id); + } + } + + fn insert_def_id(&mut self, def_id: DefId) { + if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) { + debug_assert!(!should_explore(self.tcx, node_id)); + self.live_symbols.insert(node_id); } - self.live_symbols.insert(def_id.node); } fn lookup_and_handle_definition(&mut self, id: &ast::NodeId) { @@ -94,7 +101,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { def::DefPrimTy(_) => (), def::DefVariant(enum_id, variant_id, _) => { self.check_def_id(enum_id); - if !self.ignore_variant_stack.contains(&variant_id.node) { + if !self.ignore_variant_stack.contains(&variant_id) { self.check_def_id(variant_id); } } @@ -113,7 +120,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { fn handle_field_access(&mut self, lhs: &hir::Expr, name: ast::Name) { if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(lhs).sty { - self.live_symbols.insert(def.struct_variant().field_named(name).did.node); + self.insert_def_id(def.struct_variant().field_named(name).did); } else { self.tcx.sess.span_bug(lhs.span, "named field access on non-struct") } @@ -121,7 +128,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { fn handle_tup_field_access(&mut self, lhs: &hir::Expr, idx: usize) { if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(lhs).sty { - self.live_symbols.insert(def.struct_variant().fields[idx].did.node); + self.insert_def_id(def.struct_variant().fields[idx].did); } } @@ -137,7 +144,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { if let hir::PatWild(hir::PatWildSingle) = pat.node.pat.node { continue; } - self.live_symbols.insert(variant.field_named(pat.node.name).did.node); + self.insert_def_id(variant.field_named(pat.node.name).did); } } @@ -469,8 +476,10 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { // `ctor_id`. On the other hand, in a statement like // `type = ;` where refers to a struct_ctor, // DefMap maps to `id` instead. - fn symbol_is_live(&mut self, id: ast::NodeId, - ctor_id: Option) -> bool { + fn symbol_is_live(&mut self, + id: ast::NodeId, + ctor_id: Option) + -> bool { if self.live_symbols.contains(&id) || ctor_id.map_or(false, |ctor| self.live_symbols.contains(&ctor)) { @@ -486,9 +495,11 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { Some(impl_list) => { for impl_did in impl_list.iter() { for item_did in impl_items.get(impl_did).unwrap().iter() { - if self.live_symbols.contains(&item_did.def_id() - .node) { - return true; + if let Some(item_node_id) = + self.tcx.map.as_local_node_id(item_did.def_id()) { + if self.live_symbols.contains(&item_node_id) { + return true; + } } } } diff --git a/src/librustc/middle/def_id.rs b/src/librustc/middle/def_id.rs index bbfaffb111266..f8f3412c8bb2c 100644 --- a/src/librustc/middle/def_id.rs +++ b/src/librustc/middle/def_id.rs @@ -17,13 +17,13 @@ use std::fmt; RustcDecodable, Hash, Copy)] pub struct DefId { pub krate: CrateNum, - pub node: NodeId, + pub xxx_node: NodeId, } impl fmt::Debug for DefId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "DefId {{ krate: {}, node: {}", - self.krate, self.node)); + self.krate, self.xxx_node)); // Unfortunately, there seems to be no way to attempt to print // a path for a def-id, so I'll just make a best effort for now @@ -42,13 +42,7 @@ impl fmt::Debug for DefId { impl DefId { pub fn xxx_local(id: NodeId) -> DefId { - DefId { krate: LOCAL_CRATE, node: id } - } - - /// Read the node id, asserting that this def-id is krate-local. - pub fn local_id(&self) -> NodeId { - assert_eq!(self.krate, LOCAL_CRATE); - self.node + DefId { krate: LOCAL_CRATE, xxx_node: id } } pub fn is_local(&self) -> bool { diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 262c5c1422b7c..73313a5c257a6 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -209,7 +209,7 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { 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 = DefId { krate: crate_number, node: node_id }; + let def_id = DefId { krate: crate_number, xxx_node: node_id }; self.collect_item(item_index, def_id, DUMMY_SP); true }); diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index ec7274a9b6df2..48550c3d8b2f1 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -219,7 +219,7 @@ pub fn def_to_path(tcx: &ty::ctxt, id: DefId) -> hir::Path { } /// Return variants that are necessary to exist for the pattern to match. -pub fn necessary_variants(dm: &DefMap, pat: &hir::Pat) -> Vec { +pub fn necessary_variants(dm: &DefMap, pat: &hir::Pat) -> Vec { let mut variants = vec![]; walk_pat(pat, |p| { match p.node { @@ -228,7 +228,7 @@ pub fn necessary_variants(dm: &DefMap, pat: &hir::Pat) -> Vec { hir::PatStruct(..) => { match dm.borrow().get(&p.id) { Some(&PathResolution { base_def: DefVariant(_, id, _), .. }) => { - variants.push(id.node); // XXX + variants.push(id); } _ => () } diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index bbf310b65c35d..a89da9704d9fd 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -16,7 +16,6 @@ // reachable as well. use front::map as ast_map; -use metadata::cstore::LOCAL_CRATE; use middle::def; use middle::def_id::DefId; use middle::ty; @@ -62,20 +61,15 @@ fn method_might_be_inlined(tcx: &ty::ctxt, sig: &hir::MethodSig, generics_require_inlining(&sig.generics) { return true } - if impl_src.is_local() { - { - match tcx.map.find(impl_src.node) { - Some(ast_map::NodeItem(item)) => { - item_might_be_inlined(&*item) - } - Some(..) | None => { - tcx.sess.span_bug(impl_item.span, "impl did is not an item") - } - } + if let Some(impl_node_id) = tcx.map.as_local_node_id(impl_src) { + match tcx.map.find(impl_node_id) { + Some(ast_map::NodeItem(item)) => + item_might_be_inlined(&*item), + Some(..) | None => + tcx.sess.span_bug(impl_item.span, "impl did is not an item") } } else { - tcx.sess.span_bug(impl_item.span, "found a foreign impl as a parent \ - of a local method") + tcx.sess.span_bug(impl_item.span, "found a foreign impl as a parent of a local method") } } @@ -107,22 +101,22 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ReachableContext<'a, 'tcx> { }; let def_id = def.def_id(); - if def_id.is_local() { + if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) { if self.def_id_represents_local_inlined_item(def_id) { - self.worklist.push(def_id.node) + self.worklist.push(node_id); } else { match def { // If this path leads to a constant, then we need to // recurse into the constant to continue finding // items that are reachable. def::DefConst(..) | def::DefAssociatedConst(..) => { - self.worklist.push(def_id.node); + self.worklist.push(node_id); } // If this wasn't a static, then the destination is // surely reachable. _ => { - self.reachable_symbols.insert(def_id.node); + self.reachable_symbols.insert(node_id); } } } @@ -133,11 +127,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ReachableContext<'a, 'tcx> { let def_id = self.tcx.tables.borrow().method_map[&method_call].def_id; match self.tcx.impl_or_trait_item(def_id).container() { ty::ImplContainer(_) => { - if def_id.is_local() { + if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) { if self.def_id_represents_local_inlined_item(def_id) { - self.worklist.push(def_id.node) + self.worklist.push(node_id) } - self.reachable_symbols.insert(def_id.node); + self.reachable_symbols.insert(node_id); } } ty::TraitContainer(_) => {} @@ -172,11 +166,11 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { // Returns true if the given def ID represents a local item that is // eligible for inlining and false otherwise. fn def_id_represents_local_inlined_item(&self, def_id: DefId) -> bool { - if def_id.krate != LOCAL_CRATE { - return false - } + let node_id = match self.tcx.map.as_local_node_id(def_id) { + Some(node_id) => node_id, + None => { return false; } + }; - let node_id = def_id.node; match self.tcx.map.find(node_id) { Some(ast_map::NodeItem(item)) => { match item.node { @@ -205,11 +199,8 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { // Check the impl. If the generics on the self // type of the impl require inlining, this method // does too. - assert!(impl_did.is_local()); - match self.tcx - .map - .expect_item(impl_did.node) - .node { + let impl_node_id = self.tcx.map.as_local_node_id(impl_did).unwrap(); + match self.tcx.map.expect_item(impl_node_id).node { hir::ItemImpl(_, _, ref generics, _, _, _) => { generics_require_inlining(generics) } @@ -355,8 +346,8 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { drop_trait.for_each_impl(self.tcx, |drop_impl| { for destructor in &self.tcx.impl_items.borrow()[&drop_impl] { let destructor_did = destructor.def_id(); - if destructor_did.is_local() { - self.reachable_symbols.insert(destructor_did.node); + if let Some(destructor_node_id) = self.tcx.map.as_local_node_id(destructor_did) { + self.reachable_symbols.insert(destructor_node_id); } } }) @@ -378,8 +369,10 @@ pub fn find_reachable(tcx: &ty::ctxt, } for (_, item) in tcx.lang_items.items() { match *item { - Some(did) if did.is_local() => { - reachable_context.worklist.push(did.node); + Some(did) => { + if let Some(node_id) = tcx.map.as_local_node_id(did) { + reachable_context.worklist.push(node_id); + } } _ => {} } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index b6a4c97b180bf..15a7dd426fbbe 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -383,7 +383,7 @@ pub fn check_item(tcx: &ty::ctxt, item: &hir::Item, warn_about_defns: bool, Some(cnum) => cnum, None => return, }; - let id = DefId { krate: cnum, node: ast::CRATE_NODE_ID }; + let id = DefId { krate: cnum, xxx_node: ast::CRATE_NODE_ID }; maybe_do_stability_check(tcx, id, item.span, cb); } diff --git a/src/librustc/middle/ty/error.rs b/src/librustc/middle/ty/error.rs index ba7be3e2c9948..61536934aae13 100644 --- a/src/librustc/middle/ty/error.rs +++ b/src/librustc/middle/ty/error.rs @@ -302,13 +302,15 @@ impl<'tcx> ty::ctxt<'tcx> { expected.ty, found.ty)); - match (expected.def_id.is_local(), - self.map.opt_span(expected.def_id.node)) { - (true, Some(span)) => { + match + self.map.as_local_node_id(expected.def_id) + .and_then(|node_id| self.map.opt_span(node_id)) + { + Some(span) => { self.sess.span_note(span, &format!("a default was defined here...")); } - (_, _) => { + None => { self.sess.note( &format!("a default is defined on `{}`", self.item_path_str(expected.def_id))); @@ -319,13 +321,15 @@ impl<'tcx> ty::ctxt<'tcx> { expected.origin_span, &format!("...that was applied to an unconstrained type variable here")); - match (found.def_id.is_local(), - self.map.opt_span(found.def_id.node)) { - (true, Some(span)) => { + match + self.map.as_local_node_id(found.def_id) + .and_then(|node_id| self.map.opt_span(node_id)) + { + Some(span) => { self.sess.span_note(span, &format!("a second default was defined here...")); } - (_, _) => { + None => { self.sess.note( &format!("a second default is defined on `{}`", self.item_path_str(found.def_id))); diff --git a/src/librustc/middle/ty/mod.rs b/src/librustc/middle/ty/mod.rs index a48d34281bb63..1b334e3772244 100644 --- a/src/librustc/middle/ty/mod.rs +++ b/src/librustc/middle/ty/mod.rs @@ -618,7 +618,7 @@ pub struct RegionParameterDef { impl RegionParameterDef { pub fn to_early_bound_region(&self) -> ty::Region { ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: self.def_id, + def_id: self.def_id, space: self.space, index: self.index, name: self.name, @@ -2101,8 +2101,8 @@ impl<'tcx> ctxt<'tcx> { } pub fn provided_trait_methods(&self, id: DefId) -> Vec>> { - if id.is_local() { - if let ItemTrait(_, _, _, ref ms) = self.map.expect_item(id.node).node { + if let Some(id) = self.map.as_local_node_id(id) { + if let ItemTrait(_, _, _, ref ms) = self.map.expect_item(id).node { ms.iter().filter_map(|ti| { if let hir::MethodTraitItem(_, Some(_)) = ti.node { match self.impl_or_trait_item(self.map.local_def_id(ti.id)) { @@ -2126,8 +2126,8 @@ impl<'tcx> ctxt<'tcx> { } pub fn associated_consts(&self, id: DefId) -> Vec>> { - if id.is_local() { - match self.map.expect_item(id.node).node { + if let Some(id) = self.map.as_local_node_id(id) { + match self.map.expect_item(id).node { ItemTrait(_, _, _, ref tis) => { tis.iter().filter_map(|ti| { if let hir::ConstTraitItem(_, _) = ti.node { @@ -2187,8 +2187,8 @@ impl<'tcx> ctxt<'tcx> { } pub fn trait_impl_polarity(&self, id: DefId) -> Option { - if id.is_local() { - match self.map.find(id.node) { + if let Some(id) = self.map.as_local_node_id(id) { + match self.map.find(id) { Some(ast_map::NodeItem(item)) => { match item.node { hir::ItemImpl(_, polarity, _, _, _, _) => Some(polarity), @@ -2243,9 +2243,9 @@ impl<'tcx> ctxt<'tcx> { /// Returns whether this DefId refers to an impl pub fn is_impl(&self, id: DefId) -> bool { - if id.is_local() { + if let Some(id) = self.map.as_local_node_id(id) { if let Some(ast_map::NodeItem( - &hir::Item { node: hir::ItemImpl(..), .. })) = self.map.find(id.node) { + &hir::Item { node: hir::ItemImpl(..), .. })) = self.map.find(id) { true } else { false @@ -2266,16 +2266,16 @@ impl<'tcx> ctxt<'tcx> { pub fn with_path(&self, id: DefId, f: F) -> T where F: FnOnce(ast_map::PathElems) -> T, { - if id.is_local() { - self.map.with_path(id.node, f) + if let Some(id) = self.map.as_local_node_id(id) { + self.map.with_path(id, f) } else { f(csearch::get_item_path(self, id).iter().cloned().chain(LinkedPath::empty())) } } pub fn item_name(&self, id: DefId) -> ast::Name { - if id.is_local() { - self.map.get_path_elem(id.node).name() + if let Some(id) = self.map.as_local_node_id(id) { + self.map.get_path_elem(id).name() } else { csearch::get_item_name(self, id) } @@ -2335,8 +2335,8 @@ impl<'tcx> ctxt<'tcx> { /// Get the attributes of a definition. pub fn get_attrs(&self, did: DefId) -> Cow<'tcx, [ast::Attribute]> { - if did.is_local() { - Cow::Borrowed(self.map.attrs(did.node)) + if let Some(id) = self.map.as_local_node_id(did) { + Cow::Borrowed(self.map.attrs(id)) } else { Cow::Owned(csearch::get_item_attrs(&self.sess.cstore, did)) } diff --git a/src/librustc/middle/ty/sty.rs b/src/librustc/middle/ty/sty.rs index c553e3ca5b38d..c6debc382279b 100644 --- a/src/librustc/middle/ty/sty.rs +++ b/src/librustc/middle/ty/sty.rs @@ -675,7 +675,7 @@ pub enum Region { #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)] pub struct EarlyBoundRegion { - pub param_id: DefId, + pub def_id: DefId, pub space: subst::ParamSpace, pub index: u32, pub name: Name, diff --git a/src/librustc/middle/ty/util.rs b/src/librustc/middle/ty/util.rs index a431bbaeeb8e3..2e6cc4faff8d0 100644 --- a/src/librustc/middle/ty/util.rs +++ b/src/librustc/middle/ty/util.rs @@ -461,7 +461,7 @@ impl<'tcx> ty::ctxt<'tcx> { tcx.sess.cstore.get_crate_hash(did.krate) }; h.as_str().hash(state); - did.node.hash(state); + did.xxx_node.hash(state); }; let mt = |state: &mut SipHasher, mt: TypeAndMut| { mt.mutbl.hash(state); diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 8daaf1325eae7..75099ca24bc79 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -309,18 +309,18 @@ impl<'tcx> fmt::Display for ty::TraitTy<'tcx> { impl<'tcx> fmt::Debug for ty::TypeParameterDef<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "TypeParameterDef({}, {}:{}, {:?}/{})", + write!(f, "TypeParameterDef({}, {:?}, {:?}/{})", self.name, - self.def_id.krate, self.def_id.node, + self.def_id, self.space, self.index) } } impl fmt::Debug for ty::RegionParameterDef { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "RegionParameterDef({}, {}:{}, {:?}/{}, {:?})", + write!(f, "RegionParameterDef({}, {:?}, {:?}/{}, {:?})", self.name, - self.def_id.krate, self.def_id.node, + self.def_id, self.space, self.index, self.bounds) } @@ -455,7 +455,7 @@ impl fmt::Debug for ty::BoundRegion { BrAnon(n) => write!(f, "BrAnon({:?})", n), BrFresh(n) => write!(f, "BrFresh({:?})", n), BrNamed(did, name) => { - write!(f, "BrNamed({}:{}, {:?})", did.krate, did.node, name) + write!(f, "BrNamed({:?}, {:?})", did, name) } BrEnv => "BrEnv".fmt(f), } @@ -467,7 +467,7 @@ impl fmt::Debug for ty::Region { match *self { ty::ReEarlyBound(ref data) => { write!(f, "ReEarlyBound({:?}, {:?}, {}, {})", - data.param_id, + data.def_id, data.space, data.index, data.name) @@ -888,13 +888,13 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> { TyTrait(ref data) => write!(f, "{}", data), ty::TyProjection(ref data) => write!(f, "{}", data), TyStr => write!(f, "str"), - TyClosure(ref did, ref substs) => ty::tls::with(|tcx| { + TyClosure(did, ref substs) => ty::tls::with(|tcx| { try!(write!(f, "[closure")); - if did.is_local() { - try!(write!(f, "@{:?}", tcx.map.span(did.node))); + if let Some(node_id) = tcx.map.as_local_node_id(did) { + try!(write!(f, "@{:?}", tcx.map.span(node_id))); let mut sep = " "; - try!(tcx.with_freevars(did.node, |freevars| { + try!(tcx.with_freevars(node_id, |freevars| { for (freevar, upvar_ty) in freevars.iter().zip(&substs.upvar_tys) { let node_id = freevar.def.node_id(); try!(write!(f, diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 4766fd0cfb720..175bac01daa71 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -20,7 +20,6 @@ use borrowck::LoanPathKind::{LpVar, LpUpvar, LpDowncast, LpExtend}; use borrowck::LoanPathElem::{LpDeref, LpInterior}; use borrowck::move_data::InvalidMovePathIndex; use borrowck::move_data::{MoveData, MovePathIndex}; -use rustc::metadata::cstore::LOCAL_CRATE; use rustc::middle::def_id::{DefId}; use rustc::middle::ty; use rustc::middle::mem_categorization as mc; @@ -134,7 +133,7 @@ pub fn build_unfragmented_map(this: &mut borrowck::BorrowckCtxt, } let mut fraginfo_map = this.tcx.fragment_infos.borrow_mut(); - let fn_did = DefId { krate: LOCAL_CRATE, node: id }; + let fn_did = this.tcx.map.local_def_id(id); let prev = fraginfo_map.insert(fn_did, fragment_infos); assert!(prev.is_none()); } diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 4b3b3a5e84827..dc550bb698f16 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -295,7 +295,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { { let name = token::intern(name); ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: ast::DUMMY_NODE_ID, + def_id: self.infcx.tcx.map.local_def_id(ast::DUMMY_NODE_ID), space: space, index: index, name: name diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 9d502a312616a..d4cf85d236f7a 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -202,10 +202,12 @@ impl LateLintPass for RawPointerDerive { } _ => return, }; - if !did.is_local() { + let node_id = if let Some(node_id) = cx.tcx.map.as_local_node_id(did) { + node_id + } else { return; - } - let item = match cx.tcx.map.find(did.node) { + }; + let item = match cx.tcx.map.find(node_id) { Some(hir_map::NodeItem(item)) => item, _ => return, }; @@ -458,13 +460,15 @@ impl LateLintPass for MissingDoc { // If the trait is private, add the impl items to private_traits so they don't get // reported for missing docs. let real_trait = cx.tcx.trait_ref_to_def_id(trait_ref); - match cx.tcx.map.find(real_trait.node) { - Some(hir_map::NodeItem(item)) => if item.vis == hir::Visibility::Inherited { - for itm in impl_items { - self.private_traits.insert(itm.id); - } - }, - _ => { } + if let Some(node_id) = cx.tcx.map.as_local_node_id(real_trait) { + match cx.tcx.map.find(node_id) { + Some(hir_map::NodeItem(item)) => if item.vis == hir::Visibility::Inherited { + for itm in impl_items { + self.private_traits.insert(itm.id); + } + }, + _ => { } + } } return }, @@ -629,9 +633,11 @@ impl LateLintPass for MissingDebugImplementations { let debug_def = cx.tcx.lookup_trait_def(debug); let mut impls = NodeSet(); debug_def.for_each_impl(cx.tcx, |d| { - if d.is_local() { - if let Some(ty_def) = cx.tcx.node_id_to_type(d.node).ty_to_def_id() { - impls.insert(ty_def.node); + if let Some(n) = cx.tcx.map.as_local_node_id(d) { + if let Some(ty_def) = cx.tcx.node_id_to_type(n).ty_to_def_id() { + if let Some(node_id) = cx.tcx.map.as_local_node_id(ty_def) { + impls.insert(node_id); + } } } }); @@ -956,7 +962,12 @@ impl LateLintPass for UnconditionalRecursion { traits::Obligation::new(traits::ObligationCause::misc(span, expr_id), trait_ref.to_poly_trait_predicate()); - let param_env = ty::ParameterEnvironment::for_item(tcx, method.def_id.node); + // unwrap() is ok here b/c `method` is the method + // defined in this crate whose body we are + // checking, so it's always local + let node_id = tcx.map.as_local_node_id(method.def_id).unwrap(); + + let param_env = ty::ParameterEnvironment::for_item(tcx, node_id); let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, Some(param_env), false); let mut selcx = traits::SelectionContext::new(&infcx); match selcx.select(&obligation) { diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index 920ecab7527d7..f3549e6dda7c1 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -139,8 +139,8 @@ impl LateLintPass for UnusedResults { ty::TyBool => return, ty::TyStruct(def, _) | ty::TyEnum(def, _) => { - if def.did.is_local() { - if let hir_map::NodeItem(it) = cx.tcx.map.get(def.did.node) { + if let Some(def_node_id) = cx.tcx.map.as_local_node_id(def.did) { + if let hir_map::NodeItem(it) = cx.tcx.map.get(def_node_id) { check_must_use(cx, &it.attrs, s.span) } else { false diff --git a/src/librustc_mir/tcx/expr.rs b/src/librustc_mir/tcx/expr.rs index 6560f8449c426..baa3346f83193 100644 --- a/src/librustc_mir/tcx/expr.rs +++ b/src/librustc_mir/tcx/expr.rs @@ -817,7 +817,7 @@ fn capture_freevar<'a,'tcx:'a>(cx: &mut Cx<'a,'tcx>, freevar: &ty::Freevar, freevar_ty: Ty<'tcx>) -> ExprRef> { - let id_var = freevar.def.def_id().node; + let id_var = freevar.def.node_id(); let upvar_id = ty::UpvarId { var_id: id_var, closure_expr_id: closure_expr.id }; let upvar_capture = cx.tcx.upvar_capture(upvar_id).unwrap(); let temp_lifetime = cx.tcx.region_maps.temporary_scope(closure_expr.id); diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index aa41dccc6dcd7..13b9b16e6ca45 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -265,8 +265,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { def::DefPrimTy(..) => true, def => { let did = def.def_id(); - !did.is_local() || - self.exported_items.contains(&did.node) + if let Some(node_id) = self.tcx.map.as_local_node_id(did) { + self.exported_items.contains(&node_id) + } else { + true + } } } } @@ -274,8 +277,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { }; let tr = self.tcx.impl_trait_ref(self.tcx.map.local_def_id(item.id)); let public_trait = tr.clone().map_or(false, |tr| { - !tr.def_id.is_local() || - self.exported_items.contains(&tr.def_id.node) + if let Some(node_id) = self.tcx.map.as_local_node_id(tr.def_id) { + self.exported_items.contains(&node_id) + } else { + true + } }); if public_ty || public_trait { @@ -334,8 +340,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { def::DefPrimTy(..) | def::DefTyParam(..) => {}, def => { let did = def.def_id(); - if did.is_local() { - self.exported_items.insert(did.node); + if let Some(node_id) = self.tcx.map.as_local_node_id(did) { + self.exported_items.insert(node_id); } } } @@ -363,8 +369,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { if self.prev_exported { assert!(self.export_map.contains_key(&id), "wut {}", id); for export in self.export_map.get(&id).unwrap() { - if export.def_id.is_local() { - self.reexports.insert(export.def_id.node); + if let Some(node_id) = self.tcx.map.as_local_node_id(export.def_id) { + self.reexports.insert(node_id); } } } @@ -404,7 +410,9 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { // Determines whether the given definition is public from the point of view // of the current item. fn def_privacy(&self, did: DefId) -> PrivacyResult { - if !did.is_local() { + let node_id = if let Some(node_id) = self.tcx.map.as_local_node_id(did) { + node_id + } else { if self.external_exports.contains(&did) { debug!("privacy - {:?} was externally exported", did); return Allowable; @@ -496,19 +504,19 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { ExternallyDenied } }; - } + }; debug!("privacy - local {} not public all the way down", - self.tcx.map.node_to_string(did.node)); + self.tcx.map.node_to_string(node_id)); // return quickly for things in the same module - if self.parents.get(&did.node) == self.parents.get(&self.curitem) { + if self.parents.get(&node_id) == self.parents.get(&self.curitem) { debug!("privacy - same parent, we're done here"); return Allowable; } // We now know that there is at least one private member between the // destination and the root. - let mut closest_private_id = did.node; + let mut closest_private_id = node_id; loop { debug!("privacy - examining {}", self.nodestr(closest_private_id)); let vis = match self.tcx.map.find(closest_private_id) { @@ -578,6 +586,15 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { } } + /// True if `id` is both local and private-accessible + fn local_private_accessible(&self, did: DefId) -> bool { + if let Some(node_id) = self.tcx.map.as_local_node_id(did) { + self.private_accessible(node_id) + } else { + false + } + } + /// For a local private node in the AST, this function will determine /// whether the node is accessible by the current module that iteration is /// inside. @@ -639,11 +656,15 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { DisallowedBy(id) => id, }; - // If we're disallowed by a particular id, then we attempt to give a - // nice error message to say why it was disallowed. It was either - // because the item itself is private or because its parent is private - // and its parent isn't in our ancestry. - let (err_span, err_msg) = if id == source_did.unwrap_or(to_check).node { + // If we're disallowed by a particular id, then we attempt to + // give a nice error message to say why it was disallowed. It + // was either because the item itself is private or because + // its parent is private and its parent isn't in our + // ancestry. (Both the item being checked and its parent must + // be local.) + let def_id = source_did.unwrap_or(to_check); + let node_id = self.tcx.map.as_local_node_id(def_id).unwrap(); + let (err_span, err_msg) = if id == node_id { return Some((span, format!("{} is private", msg), None)); } else { (span, format!("{} is inaccessible", msg)) @@ -663,8 +684,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { }; let def = self.tcx.def_map.borrow().get(&ty.id).unwrap().full_def(); let did = def.def_id(); - assert!(did.is_local()); - match self.tcx.map.get(did.node) { + let node_id = self.tcx.map.as_local_node_id(did).unwrap(); + match self.tcx.map.get(node_id) { ast_map::NodeItem(item) => item, _ => self.tcx.sess.span_bug(item.span, "path is not an item") @@ -699,9 +720,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { } UnnamedField(idx) => &v.fields[idx] }; - if field.vis == hir::Public || - (field.did.is_local() && self.private_accessible(field.did.node)) { - return + if field.vis == hir::Public || self.local_private_accessible(field.did) { + return; } let struct_desc = match def.adt_kind() { @@ -891,11 +911,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { _ => expr_ty }.ty_adt_def().unwrap(); let any_priv = def.struct_variant().fields.iter().any(|f| { - f.vis != hir::Public && ( - !f.did.is_local() || - !self.private_accessible(f.did.node)) - }); - + f.vis != hir::Public && !self.local_private_accessible(f.did) + }); if any_priv { span_err!(self.tcx.sess, expr.span, E0450, "cannot invoke tuple struct constructor with private \ @@ -1134,18 +1151,19 @@ impl<'a, 'tcx> VisiblePrivateTypesVisitor<'a, 'tcx> { None | Some(def::DefPrimTy(..)) => return false, Some(def) => def.def_id(), }; + // A path can only be private if: // it's in this crate... - if !did.is_local() { + if let Some(node_id) = self.tcx.map.as_local_node_id(did) { + // .. and it corresponds to a private type in the AST (this returns + // None for type parameters) + match self.tcx.map.find(node_id) { + Some(ast_map::NodeItem(ref item)) => item.vis != hir::Public, + Some(_) | None => false, + } + } else { return false } - - // .. and it corresponds to a private type in the AST (this returns - // None for type parameters) - match self.tcx.map.find(did.node) { - Some(ast_map::NodeItem(ref item)) => item.vis != hir::Public, - Some(_) | None => false, - } } fn trait_is_public(&self, trait_id: ast::NodeId) -> bool { @@ -1245,7 +1263,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { |tr| { let did = self.tcx.trait_ref_to_def_id(tr); - !did.is_local() || self.trait_is_public(did.node) + if let Some(node_id) = self.tcx.map.as_local_node_id(did) { + self.trait_is_public(node_id) + } else { + true // external traits must be public + } }); // `true` iff this is a trait impl or at least one method is public. diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 1f850fc9687c1..3a53c8b4d8c6c 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -387,7 +387,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { ItemExternCrate(_) => { // n.b. we don't need to look at the path option here, because cstore already did if let Some(crate_id) = self.session.cstore.find_extern_mod_stmt_cnum(item.id) { - let def_id = DefId { krate: crate_id, node: 0 }; + let def_id = DefId { krate: crate_id, xxx_node: 0 }; self.external_exports.insert(def_id); let parent_link = ModuleParentLink(Rc::downgrade(parent), name); let external_module = Rc::new(Module::new(parent_link, @@ -409,7 +409,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let name_bindings = self.add_child(name, parent, ForbidDuplicateModules, sp); let parent_link = self.get_parent_link(parent, name); - let def_id = DefId { krate: 0, node: item.id }; + let def_id = self.ast_map.local_def_id(item.id); name_bindings.define_module(parent_link, Some(def_id), NormalModuleKind, diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 4497bfb3898d3..e828c319a2b94 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -65,7 +65,7 @@ use rustc::util::nodemap::{NodeMap, DefIdSet, FnvHashMap}; use rustc::util::lev_distance::lev_distance; use syntax::ast; -use syntax::ast::{Ident, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64}; +use syntax::ast::{CRATE_NODE_ID, Ident, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64}; use syntax::ast::{TyUs, TyU8, TyU16, TyU32, TyU64, TyF64, TyF32}; use syntax::attr::AttrMetaMethods; use syntax::ext::mtwt; @@ -1188,8 +1188,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { make_glob_map: MakeGlobMap) -> Resolver<'a, 'tcx> { let graph_root = NameBindings::new(); + let root_def_id = ast_map.local_def_id(CRATE_NODE_ID); graph_root.define_module(NoParentLink, - Some(DefId { krate: 0, node: 0 }), + Some(root_def_id), NormalModuleKind, false, true, @@ -1257,8 +1258,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn get_trait_name(&self, did: DefId) -> Name { - if did.is_local() { - self.ast_map.expect_item(did.node).name + if let Some(node_id) = self.ast_map.as_local_node_id(did) { + self.ast_map.expect_item(node_id).name } else { csearch::get_trait_name(&self.session.cstore, did) } @@ -3498,8 +3499,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn is_static_method(this: &Resolver, did: DefId) -> bool { - if did.is_local() { - let sig = match this.ast_map.get(did.node) { + if let Some(node_id) = this.ast_map.as_local_node_id(did) { + let sig = match this.ast_map.get(node_id) { hir_map::NodeTraitItem(trait_item) => match trait_item.node { hir::MethodTraitItem(ref sig, _) => sig, _ => return false @@ -3846,9 +3847,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn add_trait_info(found_traits: &mut Vec, trait_def_id: DefId, name: Name) { - debug!("(adding trait info) found trait {}:{} for method '{}'", - trait_def_id.krate, - trait_def_id.node, + debug!("(adding trait info) found trait {:?} for method '{}'", + trait_def_id, name); found_traits.push(trait_def_id); } diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 076b2fcc004d6..0eb1e2cc06f61 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -102,9 +102,9 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { self.add_exports_for_module(&mut exports, module_); match module_.def_id.get() { Some(def_id) => { - self.export_map.insert(def_id.node, exports); // XXX - debug!("(computing exports) writing exports for {} (some)", - def_id.node); + let node_id = self.ast_map.as_local_node_id(def_id).unwrap(); + self.export_map.insert(node_id, exports); + debug!("(computing exports) writing exports for {} (some)", node_id); } None => {} } diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index c2ec4456e118a..9f963d54dc54f 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use metadata::cstore::LOCAL_CRATE; use middle::ty; use middle::def; use middle::def_id::DefId; @@ -350,8 +349,8 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { // The qualname for a method is the trait name or name of the struct in an impl in // which the method is declared in, followed by the method's name. let qualname = match self.tcx.impl_of_method(self.tcx.map.local_def_id(id)) { - Some(impl_id) => match self.tcx.map.get(impl_id.node) { - NodeItem(item) => { + Some(impl_id) => match self.tcx.map.get_if_local(impl_id) { + Some(NodeItem(item)) => { match item.node { hir::ItemImpl(_, _, _, _, ref ty, _) => { let mut result = String::from("<"); @@ -370,27 +369,27 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { } _ => { self.tcx.sess.span_bug(span, - &format!("Container {} for method {} not an impl?", - impl_id.node, id)); + &format!("Container {:?} for method {} not an impl?", + impl_id, id)); } } } - _ => { + r => { self.tcx.sess.span_bug(span, - &format!("Container {} for method {} is not a node item {:?}", - impl_id.node, id, self.tcx.map.get(impl_id.node))); - } + &format!("Container {:?} for method {} is not a node item {:?}", + impl_id, id, r)); + }, }, None => match self.tcx.trait_of_item(self.tcx.map.local_def_id(id)) { Some(def_id) => { - match self.tcx.map.get(def_id.node) { - NodeItem(_) => { + match self.tcx.map.get_if_local(def_id) { + Some(NodeItem(_)) => { format!("::{}", self.tcx.item_path_str(def_id)) } - _ => { + r => { self.tcx.sess.span_bug(span, - &format!("Could not find container {} for method {}", - def_id.node, id)); + &format!("Could not find container {:?} for method {}, got {:?}", + def_id, id, r)); } } } @@ -408,7 +407,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { self.tcx.trait_item_of_item(def_id) .and_then(|new_id| { let new_def_id = new_id.def_id(); - if new_def_id.node != 0 && new_def_id != def_id { + if new_def_id != def_id { Some(new_def_id) } else { None @@ -598,13 +597,13 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { fn trait_method_has_body(&self, mr: &ty::ImplOrTraitItem) -> bool { let def_id = mr.def_id(); - if def_id.krate != LOCAL_CRATE { - return false; - } - - let trait_item = self.tcx.map.expect_trait_item(def_id.node); - if let hir::TraitItem_::MethodTraitItem(_, Some(_)) = trait_item.node { - true + if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) { + let trait_item = self.tcx.map.expect_trait_item(node_id); + if let hir::TraitItem_::MethodTraitItem(_, Some(_)) = trait_item.node { + true + } else { + false + } } else { false } diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs index f8e6864985364..769c124299899 100644 --- a/src/librustc_trans/save/recorder.rs +++ b/src/librustc_trans/save/recorder.rs @@ -21,7 +21,7 @@ use syntax::ast; use syntax::ast::NodeId; use syntax::codemap::*; -const ZERO_DEF_ID: DefId = DefId { node: 0, krate: 0 }; +const ZERO_DEF_ID: DefId = DefId { xxx_node: 0, krate: 0 }; pub struct Recorder { // output file @@ -381,7 +381,7 @@ impl<'a> FmtStrs<'a> { decl_id: Option, scope_id: NodeId) { let values = match decl_id { - Some(decl_id) => svec!(id, name, decl_id.node, decl_id.krate, scope_id), + Some(decl_id) => svec!(id, name, decl_id.xxx_node, decl_id.krate, scope_id), None => svec!(id, name, "", "", scope_id), }; self.check_and_record(Function, @@ -442,9 +442,9 @@ impl<'a> FmtStrs<'a> { span, sub_span, svec!(id, - ref_id.node, + ref_id.xxx_node, ref_id.krate, - trait_id.node, + trait_id.xxx_node, trait_id.krate, scope_id)); } @@ -470,7 +470,7 @@ impl<'a> FmtStrs<'a> { name: &str, parent: NodeId) { let (mod_node, mod_crate) = match mod_id { - Some(mod_id) => (mod_id.node, mod_id.krate), + Some(mod_id) => (mod_id.xxx_node, mod_id.krate), None => (0, 0), }; self.check_and_record(UseAlias, @@ -513,7 +513,7 @@ impl<'a> FmtStrs<'a> { self.check_and_record(Inheritance, span, sub_span, - svec!(base_id.node, + svec!(base_id.xxx_node, base_id.krate, deriv_id, 0)); @@ -527,7 +527,7 @@ impl<'a> FmtStrs<'a> { self.check_and_record(FnCall, span, sub_span, - svec!(id.node, id.krate, "", scope_id)); + svec!(id.xxx_node, id.krate, "", scope_id)); } pub fn meth_call_str(&mut self, @@ -537,11 +537,11 @@ impl<'a> FmtStrs<'a> { declid: Option, scope_id: NodeId) { let (dfn, dfk) = match defid { - Some(defid) => (defid.node, defid.krate), + Some(defid) => (defid.xxx_node, defid.krate), None => (0, 0), }; let (dcn, dck) = match declid { - Some(declid) => (s!(declid.node), s!(declid.krate)), + Some(declid) => (s!(declid.xxx_node), s!(declid.krate)), None => ("".to_string(), "".to_string()), }; self.check_and_record(MethodCall, @@ -600,6 +600,6 @@ impl<'a> FmtStrs<'a> { self.check_and_record(kind, span, sub_span, - svec!(id.node, id.krate, "", scope_id)); + svec!(id.xxx_node, id.krate, "", scope_id)); } } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 8a0578332e6be..61244e32c7d98 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -35,7 +35,6 @@ use lint; use llvm::{BasicBlockRef, Linkage, ValueRef, Vector, get_param}; use llvm; use metadata::{csearch, encoder, loader}; -use metadata::cstore::LOCAL_CRATE; use middle::astencode; use middle::cfg; use middle::def_id::DefId; @@ -1287,7 +1286,7 @@ pub fn init_function<'a, 'tcx>(fcx: &'a FunctionContext<'a, 'tcx>, // Create the drop-flag hints for every unfragmented path in the function. let tcx = fcx.ccx.tcx(); - let fn_did = DefId { krate: LOCAL_CRATE, node: fcx.id }; + let fn_did = tcx.map.local_def_id(fcx.id); let mut hints = fcx.lldropflag_hints.borrow_mut(); let fragment_infos = tcx.fragment_infos.borrow(); @@ -2254,13 +2253,14 @@ pub fn create_entry_wrapper(ccx: &CrateContext, Ok(id) => id, Err(s) => { ccx.sess().fatal(&s[..]); } }; - let start_fn = if start_def_id.is_local() { - get_item_val(ccx, start_def_id.node) - } else { - let start_fn_type = csearch::get_type(ccx.tcx(), - start_def_id).ty; - trans_external_path(ccx, start_def_id, start_fn_type) - }; + let start_fn = + if let Some(start_node_id) = ccx.tcx().map.as_local_node_id(start_def_id) { + get_item_val(ccx, start_node_id) + } else { + let start_fn_type = csearch::get_type(ccx.tcx(), + start_def_id).ty; + trans_external_path(ccx, start_def_id, start_fn_type) + }; let args = { let opaque_rust_main = llvm::LLVMBuildPointerCast(bld, diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index 1704a8010dd8c..df9dd8feafa75 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -140,8 +140,10 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &hir::Expr) match def { def::DefFn(did, _) if { let maybe_def_id = inline::get_local_instance(bcx.ccx(), did); - let maybe_ast_node = maybe_def_id.and_then(|def_id| bcx.tcx().map - .find(def_id.node)); + let maybe_ast_node = maybe_def_id.and_then(|def_id| { + let node_id = bcx.tcx().map.as_local_node_id(def_id).unwrap(); + bcx.tcx().map.find(node_id) + }); match maybe_ast_node { Some(hir_map::NodeStructCtor(_)) => true, _ => false @@ -162,7 +164,8 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &hir::Expr) ExprId(ref_expr.id), bcx.fcx.param_substs); let def_id = inline::maybe_instantiate_inline(bcx.ccx(), did); - Callee { bcx: bcx, data: Intrinsic(def_id.node, substs), ty: expr_ty } + let node_id = bcx.tcx().map.as_local_node_id(def_id).unwrap(); + Callee { bcx: bcx, data: Intrinsic(node_id, substs), ty: expr_ty } } def::DefFn(did, _) => { fn_callee(bcx, trans_fn_ref(bcx.ccx(), did, ExprId(ref_expr.id), @@ -404,10 +407,13 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( let def_id = inline::maybe_instantiate_inline(ccx, def_id); fn is_named_tuple_constructor(tcx: &ty::ctxt, def_id: DefId) -> bool { - if !def_id.is_local() { return false; } + let node_id = match tcx.map.as_local_node_id(def_id) { + Some(n) => n, + None => { return false; } + }; let map_node = session::expect( &tcx.sess, - tcx.map.find(def_id.node), + tcx.map.find(node_id), || "local item should be in ast map".to_string()); match map_node { @@ -465,9 +471,9 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>( // Find the actual function pointer. let mut val = { - if def_id.is_local() { + if let Some(node_id) = ccx.tcx().map.as_local_node_id(def_id) { // Internal reference. - get_item_val(ccx, def_id.node) + get_item_val(ccx, node_id) } else { // External reference. trans_external_path(ccx, def_id, fn_type) diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index d992f6eeab19e..48fbbfffef656 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -44,8 +44,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Special case for small by-value selfs. let closure_id = bcx.tcx().map.local_def_id(bcx.fcx.id); - let self_type = self_type_for_closure(bcx.ccx(), closure_id, - node_id_type(bcx, closure_id.node)); + let self_type = self_type_for_closure(bcx.ccx(), closure_id, node_id_type(bcx, bcx.fcx.id)); let kind = kind_for_closure(bcx.ccx(), closure_id); let llenv = if kind == ty::FnOnceClosureKind && !arg_is_indirect(bcx.ccx(), self_type) { @@ -70,7 +69,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, for (i, freevar) in freevars.iter().enumerate() { let upvar_id = ty::UpvarId { var_id: freevar.def.node_id(), - closure_expr_id: closure_id.node }; + closure_expr_id: bcx.fcx.id }; let upvar_capture = bcx.tcx().upvar_capture(upvar_id).unwrap(); let mut upvar_ptr = StructGEP(bcx, llenv, i); let captured_by_ref = match upvar_capture { @@ -80,21 +79,21 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, true } }; - let def_id = freevar.def.def_id(); - bcx.fcx.llupvars.borrow_mut().insert(def_id.node, upvar_ptr); + let node_id = freevar.def.node_id(); + bcx.fcx.llupvars.borrow_mut().insert(node_id, upvar_ptr); if kind == ty::FnOnceClosureKind && !captured_by_ref { let hint = bcx.fcx.lldropflag_hints.borrow().hint_datum(upvar_id.var_id); bcx.fcx.schedule_drop_mem(arg_scope_id, upvar_ptr, - node_id_type(bcx, def_id.node), + node_id_type(bcx, node_id), hint) } if let Some(env_pointer_alloca) = env_pointer_alloca { debuginfo::create_captured_var_metadata( bcx, - def_id.node, + node_id, env_pointer_alloca, i, captured_by_ref, @@ -133,6 +132,8 @@ pub fn get_or_create_closure_declaration<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, closure_id: DefId, substs: &ty::ClosureSubsts<'tcx>) -> ValueRef { + let closure_node_id = ccx.tcx().map.as_local_node_id(closure_id).unwrap(); + // Normalize type so differences in regions and typedefs don't cause // duplicate declarations let substs = ccx.tcx().erase_regions(substs); @@ -147,7 +148,7 @@ pub fn get_or_create_closure_declaration<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, return llfn; } - let symbol = ccx.tcx().map.with_path(closure_id.node, |path| { + let symbol = ccx.tcx().map.with_path(closure_node_id, |path| { mangle_internal_name_by_path_and_seq(path, "closure") }); diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 41d29e0dbd89d..c7777c103e510 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -960,6 +960,9 @@ fn get_static_val<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: DefId, ty: Ty<'tcx>) -> ValueRef { - if did.is_local() { return base::get_item_val(ccx, did.node) } - base::trans_external_path(ccx, did, ty) + if let Some(node_id) = ccx.tcx().map.as_local_node_id(did) { + base::get_item_val(ccx, node_id) + } else { + base::trans_external_path(ccx, did, ty) + } } diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 75dc67bd9b09b..94c93a636a12c 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -324,8 +324,8 @@ impl<'tcx> TypeMap<'tcx> { output: &mut String) { // First, find out the 'real' def_id of the type. Items inlined from // other crates have to be mapped back to their source. - let source_def_id = if def_id.is_local() { - match cx.external_srcs().borrow().get(&def_id.node).cloned() { + let source_def_id = if let Some(node_id) = cx.tcx().map.as_local_node_id(def_id) { + match cx.external_srcs().borrow().get(&node_id).cloned() { Some(source_def_id) => { // The given def_id identifies the inlined copy of a // type definition, let's take the source of the copy. @@ -346,7 +346,7 @@ impl<'tcx> TypeMap<'tcx> { output.push_str(crate_hash.as_str()); output.push_str("/"); - output.push_str(&format!("{:x}", def_id.node)); + output.push_str(&format!("{:x}", def_id.xxx_node)); // Maybe check that there is no self type here. diff --git a/src/librustc_trans/trans/debuginfo/utils.rs b/src/librustc_trans/trans/debuginfo/utils.rs index 09d014a33823e..276f9936ac52a 100644 --- a/src/librustc_trans/trans/debuginfo/utils.rs +++ b/src/librustc_trans/trans/debuginfo/utils.rs @@ -99,12 +99,9 @@ pub fn assert_type_for_node_id(cx: &CrateContext, pub fn get_namespace_and_span_for_item(cx: &CrateContext, def_id: DefId) -> (DIScope, Span) { let containing_scope = namespace_for_item(cx, def_id).scope; - let definition_span = if def_id.is_local() { - cx.tcx().map.span(def_id.node) - } else { - // For external items there is no span information - codemap::DUMMY_SP - }; + let definition_span = cx.tcx().map.def_id_span(def_id, codemap::DUMMY_SP /* (1) */ ); + + // (1) For external items there is no span information (containing_scope, definition_span) } diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 722089e42f9be..365caadeccbc4 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -923,13 +923,13 @@ fn trans_def<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let const_ty = expr_ty(bcx, ref_expr); // For external constants, we don't inline. - let val = if did.is_local() { + let val = if let Some(node_id) = bcx.tcx().map.as_local_node_id(did) { // Case 1. // The LLVM global has the type of its initializer, // which may not be equal to the enum's type for // non-C-like enums. - let val = base::get_item_val(bcx.ccx(), did.node); + let val = base::get_item_val(bcx.ccx(), node_id); let pty = type_of::type_of(bcx.ccx(), const_ty).ptr_to(); PointerCast(bcx, val, pty) } else { diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index bf5f20d72e3f5..67abca78c6eb3 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -193,7 +193,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) pub fn get_local_instance(ccx: &CrateContext, fn_id: DefId) -> Option { - if fn_id.is_local() { + if let Some(_) = ccx.tcx().map.as_local_node_id(fn_id) { Some(fn_id) } else { instantiate_inline(ccx, fn_id) diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index df0323350fdee..39f3a29c785f4 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -38,7 +38,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_id: DefId, psubsts: &'tcx subst::Substs<'tcx>, ref_id: Option) - -> (ValueRef, Ty<'tcx>, bool) { + -> (ValueRef, Ty<'tcx>, bool) { debug!("monomorphic_fn(\ fn_id={:?}, \ real_substs={:?}, \ @@ -49,6 +49,9 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, assert!(!psubsts.types.needs_infer() && !psubsts.types.has_param_types()); + // we can only monomorphize things in this crate (or inlined into it) + let fn_node_id = ccx.tcx().map.as_local_node_id(fn_id).unwrap(); + let _icx = push_ctxt("monomorphic_fn"); let hash_id = MonoId { @@ -82,7 +85,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let map_node = session::expect( ccx.sess(), - ccx.tcx().map.find(fn_id.node), + ccx.tcx().map.find(fn_node_id), || { format!("while monomorphizing {:?}, couldn't find it in \ the item map (may have attempted to monomorphize \ @@ -91,10 +94,10 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, }); if let hir_map::NodeForeignItem(_) = map_node { - let abi = ccx.tcx().map.get_foreign_abi(fn_id.node); + let abi = ccx.tcx().map.get_foreign_abi(fn_node_id); if abi != abi::RustIntrinsic && abi != abi::PlatformIntrinsic { // Foreign externs don't have to be monomorphized. - return (get_item_val(ccx, fn_id.node), mono_ty, true); + return (get_item_val(ccx, fn_node_id), mono_ty, true); } } @@ -111,7 +114,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // recursively more than thirty times can probably safely be assumed // to be causing an infinite expansion. if depth > ccx.sess().recursion_limit.get() { - ccx.sess().span_fatal(ccx.tcx().map.span(fn_id.node), + ccx.sess().span_fatal(ccx.tcx().map.span(fn_node_id), "reached the recursion limit during monomorphization"); } @@ -125,7 +128,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, mono_ty.hash(&mut state); hash = format!("h{}", state.finish()); - ccx.tcx().map.with_path(fn_id.node, |path| { + ccx.tcx().map.with_path(fn_node_id, |path| { exported_name(path, &hash[..]) }) }; @@ -136,7 +139,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let mut hash_id = Some(hash_id); let mut mk_lldecl = |abi: abi::Abi| { let lldecl = if abi != abi::Rust { - foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, &s[..]) + foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, &s) } else { // FIXME(nagisa): perhaps needs a more fine grained selection? See // setup_lldecl below. @@ -178,10 +181,10 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, if needs_body { if abi != abi::Rust { foreign::trans_rust_fn_with_foreign_abi( - ccx, &**decl, &**body, &[], d, psubsts, fn_id.node, + ccx, &**decl, &**body, &[], d, psubsts, fn_node_id, Some(&hash[..])); } else { - trans_fn(ccx, &**decl, &**body, d, psubsts, fn_id.node, &[]); + trans_fn(ccx, &**decl, &**body, d, psubsts, fn_node_id, &[]); } } @@ -193,11 +196,11 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } } hir_map::NodeVariant(v) => { - let variant = inlined_variant_def(ccx, fn_id.node); + let variant = inlined_variant_def(ccx, fn_node_id); assert_eq!(v.node.name, variant.name); let d = mk_lldecl(abi::Rust); attributes::inline(d, attributes::InlineAttr::Hint); - trans_enum_variant(ccx, fn_id.node, variant.disr_val, psubsts, d); + trans_enum_variant(ccx, fn_node_id, variant.disr_val, psubsts, d); d } hir_map::NodeImplItem(impl_item) => { diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index c424245facca7..dd15c13256039 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -48,7 +48,6 @@ //! case but `&a` in the second. Basically, defaults that appear inside //! an rptr (`&r.T`) use the region `r` that appears in the rptr. -use metadata::cstore::LOCAL_CRATE; use middle::astconv_util::{prim_ty_to_ty, prohibit_type_params, prohibit_projection}; use middle::const_eval::{self, ConstVal}; use middle::const_eval::EvalHint::UncheckedExprHint; @@ -174,7 +173,7 @@ pub fn ast_region_to_region(tcx: &ty::ctxt, lifetime: &hir::Lifetime) Some(&rl::DefEarlyBoundRegion(space, index, id)) => { let def_id = tcx.map.local_def_id(id); ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: def_id, + def_id: def_id, space: space, index: index, name: lifetime.name @@ -1292,9 +1291,9 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, } } (&ty::TyParam(_), def::DefSelfTy(Some(trait_did), None)) => { - assert_eq!(trait_did.krate, LOCAL_CRATE); + let trait_node_id = tcx.map.as_local_node_id(trait_did).unwrap(); match find_bound_for_assoc_item(this, - trait_did.node, + trait_node_id, token::special_idents::type_self.name, assoc_name, span) { @@ -1303,9 +1302,9 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, } } (&ty::TyParam(_), def::DefTyParam(_, _, param_did, param_name)) => { - assert_eq!(param_did.krate, LOCAL_CRATE); + let param_node_id = tcx.map.as_local_node_id(param_did).unwrap(); match find_bound_for_assoc_item(this, - param_did.node, + param_node_id, param_name, assoc_name, span) { @@ -1326,10 +1325,10 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, let trait_did = bound.0.def_id; let ty = this.projected_ty_from_poly_trait_ref(span, bound, assoc_name); - let item_did = if trait_did.is_local() { + let item_did = if let Some(trait_id) = tcx.map.as_local_node_id(trait_did) { // `ty::trait_items` used below requires information generated // by type collection, which may be in progress at this point. - match tcx.map.expect_item(trait_did.node).node { + match tcx.map.expect_item(trait_id).node { hir::ItemTrait(_, _, _, ref trait_items) => { let item = trait_items.iter() .find(|i| i.name == assoc_name) @@ -1508,11 +1507,12 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx>, // we don't have the trait information around, which is just sad. if !base_segments.is_empty() { + let id_node = tcx.map.as_local_node_id(id).unwrap(); span_err!(tcx.sess, span, E0247, "found module name used as a type: {}", - tcx.map.node_to_string(id.node)); + tcx.map.node_to_user_string(id_node)); return this.tcx().types.err; } @@ -1522,10 +1522,10 @@ fn base_def_to_ty<'tcx>(this: &AstConv<'tcx>, prim_ty_to_ty(tcx, base_segments, prim_ty) } _ => { - let node = def.def_id().node; + let id_node = tcx.map.as_local_node_id(def.def_id()).unwrap(); span_err!(tcx.sess, span, E0248, "found value `{}` used as a type", - tcx.map.path_to_string(node)); + tcx.map.path_to_string(id_node)); return this.tcx().types.err; } } diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 6d8b757d16720..c46f386af277a 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -169,8 +169,8 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, // Create a parameter environment that represents the implementation's // method. - let impl_param_env = - ty::ParameterEnvironment::for_item(tcx, impl_m.def_id.node); + let impl_m_node_id = tcx.map.as_local_node_id(impl_m.def_id).unwrap(); + let impl_param_env = ty::ParameterEnvironment::for_item(tcx, impl_m_node_id); // Create mapping from impl to skolemized. let impl_to_skol_substs = &impl_param_env.free_substs; @@ -428,8 +428,8 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>, // Create a parameter environment that represents the implementation's // method. - let impl_param_env = - ty::ParameterEnvironment::for_item(tcx, impl_c.def_id.node); + let impl_c_node_id = tcx.map.as_local_node_id(impl_c.def_id).unwrap(); + let impl_param_env = ty::ParameterEnvironment::for_item(tcx, impl_c_node_id); // Create mapping from impl to skolemized. let impl_to_skol_substs = &impl_param_env.free_substs; diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index d847f481142da..870a81e510ee7 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -10,7 +10,6 @@ use check::regionck::{self, Rcx}; -use metadata::cstore::LOCAL_CRATE; use middle::def_id::DefId; use middle::free_region::FreeRegionMap; use middle::infer; @@ -78,11 +77,12 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>( drop_impl_ty: &ty::Ty<'tcx>, self_type_did: DefId) -> Result<(), ()> { - assert!(drop_impl_did.is_local() && self_type_did.is_local()); + let drop_impl_node_id = tcx.map.as_local_node_id(drop_impl_did).unwrap(); + let self_type_node_id = tcx.map.as_local_node_id(self_type_did).unwrap(); // check that the impl type can be made to match the trait type. - let impl_param_env = ty::ParameterEnvironment::for_item(tcx, self_type_did.node); + let impl_param_env = ty::ParameterEnvironment::for_item(tcx, self_type_node_id); let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, Some(impl_param_env), true); let named_type = tcx.lookup_item_type(self_type_did).ty; @@ -97,7 +97,7 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>( named_type, fresh_impl_self_ty) { span_err!(tcx.sess, drop_impl_span, E0366, "Implementations of Drop cannot be specialized"); - let item_span = tcx.map.span(self_type_did.node); + let item_span = tcx.map.span(self_type_node_id); tcx.sess.span_note(item_span, "Use same sequence of generic type and region \ parameters that is on the struct/enum definition"); @@ -111,7 +111,7 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>( } let free_regions = FreeRegionMap::new(); - infcx.resolve_regions_and_report_errors(&free_regions, drop_impl_did.node); + infcx.resolve_regions_and_report_errors(&free_regions, drop_impl_node_id); Ok(()) } @@ -159,7 +159,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>( // absent. So we report an error that the Drop impl injected a // predicate that is not present on the struct definition. - assert_eq!(self_type_did.krate, LOCAL_CRATE); + let self_type_node_id = tcx.map.as_local_node_id(self_type_did).unwrap(); let drop_impl_span = tcx.map.def_id_span(drop_impl_did, codemap::DUMMY_SP); @@ -196,7 +196,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>( // repeated `contains` calls. if !assumptions_in_impl_context.contains(&predicate) { - let item_span = tcx.map.span(self_type_did.node); + let item_span = tcx.map.span(self_type_node_id); span_err!(tcx.sess, drop_impl_span, E0367, "The requirement `{}` is added only by the Drop impl.", predicate); tcx.sess.span_note(item_span, diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index caa6b226d1b06..e10175c81aa1f 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -365,13 +365,11 @@ impl PartialOrd for TraitInfo { } impl Ord for TraitInfo { fn cmp(&self, other: &TraitInfo) -> Ordering { - // accessible traits are more important/relevant than - // inaccessible ones, local crates are more important than - // remote ones (local: cnum == 0), and NodeIds just for - // totality. + // local crates are more important than remote ones (local: + // cnum == 0), and otherwise we throw in the defid for totality - let lhs = (other.def_id.krate, other.def_id.node); - let rhs = (self.def_id.krate, self.def_id.node); + let lhs = (other.def_id.krate, other.def_id); + let rhs = (self.def_id.krate, self.def_id); lhs.cmp(&rhs) } } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 7f4b1095cb596..7d4101fa243cb 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4248,7 +4248,8 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, Some(i) => { span_err!(ccx.tcx.sess, v.span, E0081, "discriminant value `{}` already exists", disr_vals[i]); - span_note!(ccx.tcx.sess, ccx.tcx.map.span(variants[i].did.node), + let variant_i_node_id = ccx.tcx.map.as_local_node_id(variants[i].did).unwrap(); + span_note!(ccx.tcx.sess, ccx.tcx.map.span(variant_i_node_id), "conflicting discriminant here") } None => {} @@ -4275,8 +4276,8 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, } } - let hint = *ccx.tcx.lookup_repr_hints(DefId { krate: LOCAL_CRATE, node: id }) - .get(0).unwrap_or(&attr::ReprAny); + let def_id = ccx.tcx.map.local_def_id(id); + let hint = *ccx.tcx.lookup_repr_hints(def_id).get(0).unwrap_or(&attr::ReprAny); if hint != attr::ReprAny && vs.len() <= 1 { if vs.len() == 1 { diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index 590b7e50e9438..0024b51ae0f91 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -235,16 +235,16 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> { tcx.with_freevars(closure_id, |freevars| { freevars.iter() .map(|freevar| { - let freevar_def_id = freevar.def.def_id(); - let freevar_ty = self.fcx.node_ty(freevar_def_id.node); + let freevar_node_id = freevar.def.node_id(); + let freevar_ty = self.fcx.node_ty(freevar_node_id); let upvar_id = ty::UpvarId { - var_id: freevar_def_id.node, + var_id: freevar_node_id, closure_expr_id: closure_id }; let capture = self.fcx.infcx().upvar_capture(upvar_id).unwrap(); - debug!("freevar_def_id={:?} freevar_ty={:?} capture={:?}", - freevar_def_id, freevar_ty, capture); + debug!("freevar_node_id={:?} freevar_ty={:?} capture={:?}", + freevar_node_id, freevar_ty, capture); match capture { ty::UpvarCapture::ByValue => freevar_ty, diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 68c0f130c20f1..16884e76a8ec7 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -388,8 +388,8 @@ impl ResolveReason { tcx.expr_span(upvar_id.closure_expr_id) } ResolvingClosure(did) => { - if did.is_local() { - tcx.expr_span(did.node) + if let Some(node_id) = tcx.map.as_local_node_id(did) { + tcx.expr_span(node_id) } else { DUMMY_SP } diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index ddb11c910b19e..b3ec10a8941dc 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -16,7 +16,6 @@ // mappings. That mapping code resides here. -use metadata::cstore::LOCAL_CRATE; use middle::def_id::DefId; use middle::lang_items::UnsizeTraitLangItem; use middle::subst::{self, Subst}; @@ -247,17 +246,15 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } _ => { // Destructors only work on nominal types. - if impl_did.is_local() { - { - match tcx.map.find(impl_did.node) { - Some(hir_map::NodeItem(item)) => { - span_err!(tcx.sess, item.span, E0120, - "the Drop trait may only be implemented on structures"); - } - _ => { - tcx.sess.bug("didn't find impl in ast \ - map"); - } + if let Some(impl_node_id) = tcx.map.as_local_node_id(impl_did) { + match tcx.map.find(impl_node_id) { + Some(hir_map::NodeItem(item)) => { + span_err!(tcx.sess, item.span, E0120, + "the Drop trait may only be implemented on structures"); + } + _ => { + tcx.sess.bug("didn't find impl in ast \ + map"); } } } else { @@ -283,18 +280,20 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { debug!("check_implementations_of_copy: impl_did={:?}", impl_did); - if impl_did.krate != LOCAL_CRATE { + let impl_node_id = if let Some(n) = tcx.map.as_local_node_id(impl_did) { + n + } else { debug!("check_implementations_of_copy(): impl not in this \ crate"); return - } + }; let self_type = tcx.lookup_item_type(impl_did); debug!("check_implementations_of_copy: self_type={:?} (bound)", self_type); - let span = tcx.map.span(impl_did.node); - let param_env = ParameterEnvironment::for_item(tcx, impl_did.node); + let span = tcx.map.span(impl_node_id); + let param_env = ParameterEnvironment::for_item(tcx, impl_node_id); let self_type = self_type.ty.subst(tcx, ¶m_env.free_substs); assert!(!self_type.has_escaping_regions()); @@ -352,11 +351,13 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { debug!("check_implementations_of_coerce_unsized: impl_did={:?}", impl_did); - if impl_did.krate != LOCAL_CRATE { + let impl_node_id = if let Some(n) = tcx.map.as_local_node_id(impl_did) { + n + } else { debug!("check_implementations_of_coerce_unsized(): impl not \ in this crate"); return; - } + }; let source = tcx.lookup_item_type(impl_did).ty; let trait_ref = self.crate_context.tcx.impl_trait_ref(impl_did).unwrap(); @@ -364,8 +365,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { debug!("check_implementations_of_coerce_unsized: {:?} -> {:?} (bound)", source, target); - let span = tcx.map.span(impl_did.node); - let param_env = ParameterEnvironment::for_item(tcx, impl_did.node); + let span = tcx.map.span(impl_node_id); + let param_env = ParameterEnvironment::for_item(tcx, impl_node_id); let source = source.subst(tcx, ¶m_env.free_substs); let target = target.subst(tcx, ¶m_env.free_substs); assert!(!source.has_escaping_regions()); @@ -465,7 +466,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut(); // Register an obligation for `A: Trait`. - let cause = traits::ObligationCause::misc(span, impl_did.node); + let cause = traits::ObligationCause::misc(span, impl_node_id); let predicate = traits::predicate_for_trait_def(tcx, cause, trait_def_id, 0, source, vec![target]); fulfill_cx.register_predicate_obligation(&infcx, predicate); @@ -479,7 +480,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let mut free_regions = FreeRegionMap::new(); free_regions.relate_free_regions_from_predicates(tcx, &infcx.parameter_environment .caller_bounds); - infcx.resolve_regions_and_report_errors(&free_regions, impl_did.node); + infcx.resolve_regions_and_report_errors(&free_regions, impl_node_id); if let Some(kind) = kind { tcx.custom_coerce_unsized_kinds.borrow_mut().insert(impl_did, kind); diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index a2c8e8fd131fc..706f28f9fe4b0 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -112,7 +112,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { } } else if impl2_def_id.krate != LOCAL_CRATE { Some((impl1_def_id, impl2_def_id)) - } else if impl1_def_id.node < impl2_def_id.node { + } else if impl1_def_id < impl2_def_id { Some((impl1_def_id, impl2_def_id)) } else { Some((impl2_def_id, impl1_def_id)) @@ -165,8 +165,8 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { } fn span_of_impl(&self, impl_did: DefId) -> Span { - assert_eq!(impl_did.krate, LOCAL_CRATE); - self.tcx.map.span(impl_did.node) + let node_id = self.tcx.map.as_local_node_id(impl_did).unwrap(); + self.tcx.map.span(node_id) } } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index e24d3f340b6e7..39805bfc8a3e2 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -65,7 +65,6 @@ There are some shortcomings in this design: */ use astconv::{self, AstConv, ty_of_arg, ast_ty_to_ty, ast_region_to_region}; -use metadata::cstore::LOCAL_CRATE; use middle::def; use middle::def_id::DefId; use constrained_type_params as ctp; @@ -317,16 +316,16 @@ impl<'a,'tcx> CrateCtxt<'a,'tcx> { { let tcx = self.tcx; - if trait_id.krate != LOCAL_CRATE { - return tcx.lookup_trait_def(trait_id) - } - - let item = match tcx.map.get(trait_id.node) { - hir_map::NodeItem(item) => item, - _ => tcx.sess.bug(&format!("get_trait_def({:?}): not an item", trait_id)) - }; + if let Some(trait_id) = tcx.map.as_local_node_id(trait_id) { + let item = match tcx.map.get(trait_id) { + hir_map::NodeItem(item) => item, + _ => tcx.sess.bug(&format!("get_trait_def({:?}): not an item", trait_id)) + }; - trait_def_of_item(self, &*item) + trait_def_of_item(self, &*item) + } else { + tcx.lookup_trait_def(trait_id) + } } /// Ensure that the (transitive) super predicates for @@ -403,8 +402,8 @@ impl<'a, 'tcx> AstConv<'tcx> for ItemCtxt<'a, 'tcx> { assoc_name: ast::Name) -> bool { - if trait_def_id.is_local() { - trait_defines_associated_type_named(self.ccx, trait_def_id.node, assoc_name) + if let Some(trait_id) = self.tcx().map.as_local_node_id(trait_def_id) { + trait_defines_associated_type_named(self.ccx, trait_id, assoc_name) } else { let trait_def = self.tcx().lookup_trait_def(trait_def_id); trait_def.associated_type_names.contains(&assoc_name) @@ -558,8 +557,8 @@ fn is_param<'tcx>(tcx: &ty::ctxt<'tcx>, if let hir::TyPath(None, _) = ast_ty.node { let path_res = *tcx.def_map.borrow().get(&ast_ty.id).unwrap(); match path_res.base_def { - def::DefSelfTy(Some(def_id), None) => { // XXX - path_res.depth == 0 && def_id.node == param_id + def::DefSelfTy(Some(def_id), None) => { + path_res.depth == 0 && def_id == tcx.map.local_def_id(param_id) } def::DefTyParam(_, _, def_id, _) => { path_res.depth == 0 && def_id == tcx.map.local_def_id(param_id) @@ -1271,19 +1270,19 @@ fn ensure_super_predicates_step(ccx: &CrateCtxt, debug!("ensure_super_predicates_step(trait_def_id={:?})", trait_def_id); - if trait_def_id.krate != LOCAL_CRATE { + let trait_node_id = if let Some(n) = tcx.map.as_local_node_id(trait_def_id) { + n + } else { // If this trait comes from an external crate, then all of the // supertraits it may depend on also must come from external // crates, and hence all of them already have their // super-predicates "converted" (and available from crate // meta-data), so there is no need to transitively test them. return Vec::new(); - } + }; let superpredicates = tcx.super_predicates.borrow().get(&trait_def_id).cloned(); let superpredicates = superpredicates.unwrap_or_else(|| { - let trait_node_id = trait_def_id.node; - let item = match ccx.tcx.map.get(trait_node_id) { hir_map::NodeItem(item) => item, _ => ccx.tcx.sess.bug(&format!("trait_node_id {} is not an item", trait_node_id)) @@ -1412,15 +1411,12 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, generics.lifetimes .iter() .enumerate() - .map(|(i, def)| { - let def_id = tcx.map.local_def_id(def.lifetime.id); - ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: def_id, - space: TypeSpace, - index: i as u32, - name: def.lifetime.name - }) - }) + .map(|(i, def)| ty::ReEarlyBound(ty::EarlyBoundRegion { + def_id: tcx.map.local_def_id(def.lifetime.id), + space: TypeSpace, + index: i as u32, + name: def.lifetime.name + })) .collect(); // Start with the generics in the type parameters... @@ -1540,23 +1536,23 @@ fn type_scheme_of_def_id<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, def_id: DefId) -> ty::TypeScheme<'tcx> { - if def_id.krate != LOCAL_CRATE { - return ccx.tcx.lookup_item_type(def_id); - } - - match ccx.tcx.map.find(def_id.node) { - Some(hir_map::NodeItem(item)) => { - type_scheme_of_item(ccx, &*item) - } - Some(hir_map::NodeForeignItem(foreign_item)) => { - let abi = ccx.tcx.map.get_foreign_abi(def_id.node); - type_scheme_of_foreign_item(ccx, &*foreign_item, abi) - } - x => { - ccx.tcx.sess.bug(&format!("unexpected sort of node \ - in get_item_type_scheme(): {:?}", - x)); + if let Some(node_id) = ccx.tcx.map.as_local_node_id(def_id) { + match ccx.tcx.map.find(node_id) { + Some(hir_map::NodeItem(item)) => { + type_scheme_of_item(ccx, &*item) + } + Some(hir_map::NodeForeignItem(foreign_item)) => { + let abi = ccx.tcx.map.get_foreign_abi(node_id); + type_scheme_of_foreign_item(ccx, &*foreign_item, abi) + } + x => { + ccx.tcx.sess.bug(&format!("unexpected sort of node \ + in get_item_type_scheme(): {:?}", + x)); + } } + } else { + ccx.tcx.lookup_item_type(def_id) } } @@ -1894,7 +1890,7 @@ fn ty_generic_predicates<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, let def_id = tcx.map.local_def_id(param.lifetime.id); let region = ty::ReEarlyBound(ty::EarlyBoundRegion { - param_id: def_id, + def_id: def_id, space: space, index: index, name: param.lifetime.name @@ -2392,9 +2388,10 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( tcx.fold_regions(value, &mut false, |region, _| { match region { ty::ReEarlyBound(data) => { - let def_id = data.param_id; - ty::ReFree(ty::FreeRegion { scope: scope, - bound_region: ty::BrNamed(def_id, data.name) }) + ty::ReFree(ty::FreeRegion { + scope: scope, + bound_region: ty::BrNamed(data.def_id, data.name) + }) } _ => region } @@ -2453,7 +2450,7 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, for (index, lifetime_def) in ast_generics.lifetimes.iter().enumerate() { let def_id = tcx.map.local_def_id(lifetime_def.lifetime.id); - let region = ty::EarlyBoundRegion { param_id: def_id, + let region = ty::EarlyBoundRegion { def_id: def_id, space: TypeSpace, index: index as u32, name: lifetime_def.lifetime.name }; diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 86a97f305aa69..8152e685d8d83 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -266,7 +266,6 @@ use self::ParamKind::*; use arena; use arena::TypedArena; -use metadata::cstore::LOCAL_CRATE; use middle::def_id::DefId; use middle::resolve_lifetime as rl; use middle::subst; @@ -404,10 +403,10 @@ fn lang_items(tcx: &ty::ctxt) -> Vec<(ast::NodeId,Vec)> { ]; - all.into_iter() + all.into_iter() // iterating over (Option, Variance) .filter(|&(ref d,_)| d.is_some()) - .filter(|&(ref d,_)| d.as_ref().unwrap().is_local()) - .map(|(d, v)| (d.unwrap().node, v)) + .map(|(d, v)| (d.unwrap(), v)) // (DefId, Variance) + .filter_map(|(d, v)| tcx.map.as_local_node_id(d).map(|n| (n, v))) // (NodeId, Variance) .collect() } @@ -741,11 +740,11 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { -> VarianceTermPtr<'a> { assert_eq!(param_def_id.krate, item_def_id.krate); - if param_def_id.is_local() { + if let Some(param_node_id) = self.tcx().map.as_local_node_id(param_def_id) { // Parameter on an item defined within current crate: // variance not yet inferred, so return a symbolic // variance. - let InferredIndex(index) = self.inferred_index(param_def_id.node); + let InferredIndex(index) = self.inferred_index(param_node_id); self.terms_cx.inferred_infos[index].term } else { // Parameter on an item defined within another crate: @@ -924,8 +923,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { ty::TyParam(ref data) => { let def_id = generics.types.get(data.space, data.idx as usize).def_id; - assert_eq!(def_id.krate, LOCAL_CRATE); - match self.terms_cx.inferred_map.get(&def_id.node) { + let node_id = self.tcx().map.as_local_node_id(def_id).unwrap(); + match self.terms_cx.inferred_map.get(&node_id) { Some(&index) => { self.add_constraint(index, variance); } @@ -1013,7 +1012,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance: VarianceTermPtr<'a>) { match region { ty::ReEarlyBound(ref data) => { - let node_id = self.tcx().map.as_local_node_id(data.param_id).unwrap(); + let node_id = self.tcx().map.as_local_node_id(data.def_id).unwrap(); if self.is_to_be_inferred(node_id) { let index = self.inferred_index(node_id); self.add_constraint(index, variance); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index e6580a2c03778..344008b904eb9 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -36,7 +36,6 @@ use syntax::ptr::P; use rustc_trans::back::link; use rustc::metadata::cstore; -use rustc::metadata::cstore::LOCAL_CRATE; use rustc::metadata::csearch; use rustc::metadata::decoder; use rustc::middle::def; @@ -496,7 +495,7 @@ impl Clean for hir::TyParam { fn clean(&self, cx: &DocContext) -> TyParam { TyParam { name: self.name.clean(cx), - did: DefId { krate: LOCAL_CRATE, node: self.id }, + did: cx.map.local_def_id(self.id), bounds: self.bounds.clean(cx), default: self.default.clean(cx), } @@ -1138,10 +1137,10 @@ impl<'tcx> Clean for ty::FnOutput<'tcx> { impl<'a, 'tcx> Clean for (DefId, &'a ty::PolyFnSig<'tcx>) { fn clean(&self, cx: &DocContext) -> FnDecl { let (did, sig) = *self; - let mut names = if did.node != 0 { - csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).into_iter() + let mut names = if let Some(_) = cx.map.as_local_node_id(did) { + vec![].into_iter() } else { - Vec::new().into_iter() + csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).into_iter() }.peekable(); if names.peek().map(|s| &**s) == Some("self") { let _ = names.next(); @@ -1745,7 +1744,7 @@ impl<'tcx> Clean for ty::FieldDefData<'tcx, 'static> { let (name, attrs) = if self.name == unnamed_field.name { (None, None) } else { - (Some(self.name), Some(attr_map.get(&self.did.node).unwrap())) + (Some(self.name), Some(attr_map.get(&self.did.xxx_node).unwrap())) }; Item { diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 8bc832a68dbd7..c84a7e7c560dd 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -13,9 +13,10 @@ use rustc_lint; use rustc_driver::{driver, target_features}; use rustc::session::{self, config}; use rustc::middle::def_id::DefId; -use rustc::middle::{privacy, ty}; +use rustc::middle::ty; use rustc::front::map as hir_map; use rustc::lint; +use rustc::util::nodemap::DefIdSet; use rustc_trans::back::link; use rustc_resolve as resolve; use rustc_front::lowering::lower_crate; @@ -76,8 +77,8 @@ impl<'b, 'tcx> DocContext<'b, 'tcx> { } pub struct CrateAnalysis { - pub exported_items: privacy::ExportedItems, - pub public_items: privacy::PublicItems, + pub exported_items: DefIdSet, + pub public_items: DefIdSet, pub external_paths: ExternalPaths, pub external_typarams: RefCell>>, pub inlined: RefCell>>, @@ -146,6 +147,17 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec, externs: Externs, |tcx, analysis| { let ty::CrateAnalysis { exported_items, public_items, .. } = analysis; + // Convert from a NodeId set to a DefId set since we don't always have easy access + // to the map from defid -> nodeid + let exported_items: DefIdSet = + exported_items.into_iter() + .map(|n| tcx.map.local_def_id(n)) + .collect(); + let public_items: DefIdSet = + public_items.into_iter() + .map(|n| tcx.map.local_def_id(n)) + .collect(); + let ctxt = DocContext { map: &tcx.map, maybe_typed: Typed(tcx), diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index f1c3e97a9006c..6937dbf255e2e 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -387,7 +387,7 @@ fn primitive_link(f: &mut fmt::Formatter, Some(&cnum) => { let path = &m.paths[&DefId { krate: cnum, - node: ast::CRATE_NODE_ID, + xxx_node: ast::CRATE_NODE_ID, }]; let loc = match m.extern_locations[&cnum] { (_, render::Remote(ref s)) => Some(s.to_string()), diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index c392e75ebf91a..708c8f634f553 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -54,8 +54,8 @@ use externalfiles::ExternalHtml; use serialize::json::{self, ToJson}; use syntax::{abi, ast, attr}; use rustc::metadata::cstore::LOCAL_CRATE; -use rustc::middle::def_id::{DefId, LOCAL_CRATE}; -use rustc::util::nodemap::NodeSet; +use rustc::middle::def_id::DefId; +use rustc::util::nodemap::DefIdSet; use rustc_front::hir; use clean::{self, SelfTy}; @@ -206,7 +206,7 @@ pub struct Cache { search_index: Vec, privmod: bool, remove_priv: bool, - public_items: NodeSet, + public_items: DefIdSet, deref_trait_did: Option, // In rare case where a structure is defined in one module but implemented @@ -378,7 +378,7 @@ pub fn run(mut krate: clean::Crate, let analysis = ::ANALYSISKEY.with(|a| a.clone()); let analysis = analysis.borrow(); let public_items = analysis.as_ref().map(|a| a.public_items.clone()); - let public_items = public_items.unwrap_or(NodeSet()); + let public_items = public_items.unwrap_or(DefIdSet()); let paths: HashMap, ItemType)> = analysis.as_ref().map(|a| { let paths = a.external_paths.borrow_mut().take().unwrap(); @@ -413,7 +413,7 @@ pub fn run(mut krate: clean::Crate, for &(n, ref e) in &krate.externs { cache.extern_locations.insert(n, (e.name.clone(), extern_location(e, &cx.dst))); - let did = DefId { krate: n, node: ast::CRATE_NODE_ID }; + let did = DefId { krate: n, xxx_node: ast::CRATE_NODE_ID }; cache.paths.insert(did, (vec![e.name.to_string()], ItemType::Module)); } @@ -994,10 +994,11 @@ impl DocFolder for Cache { // `public_items` map, so we can skip inserting into the // paths map if there was already an entry present and we're // not a public item. - let id = item.def_id.node; - if !self.paths.contains_key(&item.def_id) || - !item.def_id.is_local() || - self.public_items.contains(&id) { + if + !self.paths.contains_key(&item.def_id) || + !item.def_id.is_local() || + self.public_items.contains(&item.def_id) + { self.paths.insert(item.def_id, (self.stack.clone(), shortty(&item))); } @@ -1079,7 +1080,7 @@ impl DocFolder for Cache { t.primitive_type().and_then(|t| { self.primitive_locations.get(&t).map(|n| { let id = t.to_node_id(); - DefId { krate: *n, node: id } + DefId { krate: *n, xxx_node: id } }) }) } @@ -1420,7 +1421,7 @@ impl<'a> Item<'a> { root = root, path = path[..path.len() - 1].join("/"), file = item_path(self.item), - goto = self.item.def_id.node)) + goto = self.item.def_id.xxx_node)) } } } @@ -1480,7 +1481,7 @@ impl<'a> fmt::Display for Item<'a> { Some(l) => { try!(write!(fmt, "[src]", - self.item.def_id.node, l, "goto source code")); + self.item.def_id.xxx_node, l, "goto source code")); } None => {} } @@ -2336,7 +2337,7 @@ fn render_deref_methods(w: &mut fmt::Formatter, cx: &Context, impl_: &Impl) -> f _ => { if let Some(prim) = target.primitive_type() { if let Some(c) = cache().primitive_locations.get(&prim) { - let did = DefId { krate: *c, node: prim.to_node_id() }; + let did = DefId { krate: *c, xxx_node: prim.to_node_id() }; try!(render_assoc_items(w, cx, did, what)); } } diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs index 8a57a50bdea41..e7e38220825f7 100644 --- a/src/librustdoc/passes.rs +++ b/src/librustdoc/passes.rs @@ -8,12 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashSet; -use rustc::util::nodemap::NodeSet; +use rustc::util::nodemap::DefIdSet; use std::cmp; use std::string::String; use std::usize; -use syntax::ast; use rustc_front::hir; use clean; @@ -24,18 +22,18 @@ use fold::DocFolder; /// Strip items marked `#[doc(hidden)]` pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { - let mut stripped = HashSet::new(); + let mut stripped = DefIdSet(); // strip all #[doc(hidden)] items let krate = { struct Stripper<'a> { - stripped: &'a mut HashSet + stripped: &'a mut DefIdSet }; impl<'a> fold::DocFolder for Stripper<'a> { fn fold_item(&mut self, i: Item) -> Option { if i.is_hidden_from_doc() { debug!("found one in strip_hidden; removing"); - self.stripped.insert(i.def_id.node); + self.stripped.insert(i.def_id); // use a dedicated hidden item for given item type if any match i.inner { @@ -61,7 +59,7 @@ pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { // strip any traits implemented on stripped items let krate = { struct ImplStripper<'a> { - stripped: &'a mut HashSet + stripped: &'a mut DefIdSet }; impl<'a> fold::DocFolder for ImplStripper<'a> { fn fold_item(&mut self, i: Item) -> Option { @@ -70,12 +68,12 @@ pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { ref trait_, .. }) = i.inner { // Impls for stripped types don't need to exist - if self.stripped.contains(&did.node) { + if self.stripped.contains(&did) { return None; } // Impls of stripped traits also don't need to exist if let Some(clean::ResolvedPath { did, .. }) = *trait_ { - if self.stripped.contains(&did.node) { + if self.stripped.contains(&did) { return None; } } @@ -94,7 +92,7 @@ pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { /// crate, specified by the `xcrate` flag. pub fn strip_private(mut krate: clean::Crate) -> plugins::PluginResult { // This stripper collects all *retained* nodes. - let mut retained = HashSet::new(); + let mut retained = DefIdSet(); let analysis = super::ANALYSISKEY.with(|a| a.clone()); let analysis = analysis.borrow(); let analysis = analysis.as_ref().unwrap(); @@ -118,8 +116,8 @@ pub fn strip_private(mut krate: clean::Crate) -> plugins::PluginResult { } struct Stripper<'a> { - retained: &'a mut HashSet, - exported_items: &'a NodeSet, + retained: &'a mut DefIdSet, + exported_items: &'a DefIdSet, } impl<'a> fold::DocFolder for Stripper<'a> { @@ -132,7 +130,7 @@ impl<'a> fold::DocFolder for Stripper<'a> { clean::VariantItem(..) | clean::MethodItem(..) | clean::ForeignFunctionItem(..) | clean::ForeignStaticItem(..) => { if i.def_id.is_local() { - if !self.exported_items.contains(&i.def_id.node) { + if !self.exported_items.contains(&i.def_id) { return None; } // Traits are in exported_items even when they're totally private. @@ -143,8 +141,7 @@ impl<'a> fold::DocFolder for Stripper<'a> { } clean::ConstantItem(..) => { - if i.def_id.is_local() && - !self.exported_items.contains(&i.def_id.node) { + if i.def_id.is_local() && !self.exported_items.contains(&i.def_id) { return None; } } @@ -171,8 +168,7 @@ impl<'a> fold::DocFolder for Stripper<'a> { clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ did, .. }, .. }) => { - if did.is_local() && - !self.exported_items.contains(&did.node) { + if did.is_local() && !self.exported_items.contains(&did) { return None; } } @@ -205,7 +201,7 @@ impl<'a> fold::DocFolder for Stripper<'a> { }; let i = if fastreturn { - self.retained.insert(i.def_id.node); + self.retained.insert(i.def_id); return Some(i); } else { self.fold_item_recur(i) @@ -220,7 +216,7 @@ impl<'a> fold::DocFolder for Stripper<'a> { i.doc_value().is_none() => None, clean::ImplItem(ref i) if i.items.is_empty() => None, _ => { - self.retained.insert(i.def_id.node); + self.retained.insert(i.def_id); Some(i) } } @@ -231,14 +227,13 @@ impl<'a> fold::DocFolder for Stripper<'a> { } // This stripper discards all private impls of traits -struct ImplStripper<'a>(&'a HashSet); +struct ImplStripper<'a>(&'a DefIdSet); impl<'a> fold::DocFolder for ImplStripper<'a> { fn fold_item(&mut self, i: Item) -> Option { if let clean::ImplItem(ref imp) = i.inner { match imp.trait_ { Some(clean::ResolvedPath{ did, .. }) => { - let ImplStripper(s) = *self; - if did.is_local() && !s.contains(&did.node) { + if did.is_local() && !self.0.contains(&did) { return None; } } diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index f9c8f2a0b8dff..9972ede8b8f9f 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -205,16 +205,18 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { None => return false }; let def = tcx.def_map.borrow()[&id].def_id(); - if !def.is_local() { return false } + let def_node_id = match tcx.map.as_local_node_id(def) { + Some(n) => n, None => return false + }; let analysis = match self.analysis { Some(analysis) => analysis, None => return false }; - if !please_inline && analysis.public_items.contains(&def.node) { + if !please_inline && analysis.public_items.contains(&def) { return false } - if !self.view_item_stack.insert(def.node) { return false } + if !self.view_item_stack.insert(def_node_id) { return false } - let ret = match tcx.map.get(def.node) { + let ret = match tcx.map.get(def_node_id) { hir_map::NodeItem(it) => { if glob { let prev = mem::replace(&mut self.inlining_from_glob, true); @@ -235,7 +237,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { } _ => false, }; - self.view_item_stack.remove(&id); + self.view_item_stack.remove(&def_node_id); return ret; } From 1dd5ffa4052720d15f38ec283a2da9e5bb5934cb Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 7 Sep 2015 14:10:25 -0400 Subject: [PATCH 06/17] Rename `node_id` to `var_id` and limit to the cases that are actually used --- src/librustc/middle/astencode.rs | 2 +- src/librustc/middle/def.rs | 17 +++++++---------- src/librustc/middle/expr_use_visitor.rs | 4 ++-- src/librustc/util/ppaux.rs | 2 +- src/librustc_mir/tcx/expr.rs | 2 +- src/librustc_trans/trans/closure.rs | 6 +++--- src/librustc_typeck/check/upvar.rs | 4 ++-- 7 files changed, 17 insertions(+), 20 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index a06a6b2509af8..6125b7897723c 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -934,7 +934,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, rbml_w.tag(c::tag_table_upvar_capture_map, |rbml_w| { rbml_w.id(id); - let var_id = freevar.def.node_id(); + let var_id = freevar.def.var_id(); let upvar_id = ty::UpvarId { var_id: var_id, closure_expr_id: id diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index 58d747002c927..ee1319a325e42 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -114,21 +114,18 @@ pub struct Export { } impl Def { - pub fn node_id(&self) -> ast::NodeId { + pub fn var_id(&self) -> ast::NodeId { match *self { DefLocal(id) | - DefUpvar(id, _, _) | - DefRegion(id) | - DefLabel(id) | - DefSelfTy(_, Some((_, id))) => { + DefUpvar(id, _, _) => { id } - DefFn(_, _) | DefMod(_) | DefForeignMod(_) | DefStatic(_, _) | - DefVariant(_, _, _) | DefTy(_, _) | DefAssociatedTy(_, _) | - DefTyParam(_, _, _, _) | DefUse(_) | DefStruct(_) | DefTrait(_) | - DefMethod(_) | DefConst(_) | DefAssociatedConst(_) | - DefSelfTy(Some(_), None) | DefPrimTy(_) | DefSelfTy(..) => { + DefFn(..) | DefMod(..) | DefForeignMod(..) | DefStatic(..) | + DefVariant(..) | DefTy(..) | DefAssociatedTy(..) | + DefTyParam(..) | DefUse(..) | DefStruct(..) | DefTrait(..) | + DefMethod(..) | DefConst(..) | DefAssociatedConst(..) | + DefPrimTy(..) | DefRegion(..) | DefLabel(..) | DefSelfTy(..) => { panic!("attempted .def_id() on invalid {:?}", self) } } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 86b321a94550c..e69b805e83340 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -1160,7 +1160,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { self.tcx().with_freevars(closure_expr.id, |freevars| { for freevar in freevars { - let id_var = freevar.def.node_id(); + let id_var = freevar.def.var_id(); let upvar_id = ty::UpvarId { var_id: id_var, closure_expr_id: closure_expr.id }; let upvar_capture = self.typer.upvar_capture(upvar_id).unwrap(); @@ -1192,7 +1192,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { -> mc::McResult> { // Create the cmt for the variable being borrowed, from the // caller's perspective - let var_id = upvar_def.node_id(); + let var_id = upvar_def.var_id(); let var_ty = try!(self.typer.node_ty(var_id)); self.mc.cat_def(closure_id, closure_span, var_ty, upvar_def) } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 75099ca24bc79..e4eba8aefcc49 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -896,7 +896,7 @@ impl<'tcx> fmt::Display for ty::TypeVariants<'tcx> { let mut sep = " "; try!(tcx.with_freevars(node_id, |freevars| { for (freevar, upvar_ty) in freevars.iter().zip(&substs.upvar_tys) { - let node_id = freevar.def.node_id(); + let node_id = freevar.def.var_id(); try!(write!(f, "{}{}:{}", sep, diff --git a/src/librustc_mir/tcx/expr.rs b/src/librustc_mir/tcx/expr.rs index baa3346f83193..8cfcf1dd565c8 100644 --- a/src/librustc_mir/tcx/expr.rs +++ b/src/librustc_mir/tcx/expr.rs @@ -817,7 +817,7 @@ fn capture_freevar<'a,'tcx:'a>(cx: &mut Cx<'a,'tcx>, freevar: &ty::Freevar, freevar_ty: Ty<'tcx>) -> ExprRef> { - let id_var = freevar.def.node_id(); + let id_var = freevar.def.var_id(); let upvar_id = ty::UpvarId { var_id: id_var, closure_expr_id: closure_expr.id }; let upvar_capture = cx.tcx.upvar_capture(upvar_id).unwrap(); let temp_lifetime = cx.tcx.region_maps.temporary_scope(closure_expr.id); diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index 48fbbfffef656..89724c38cb2c9 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -68,7 +68,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }; for (i, freevar) in freevars.iter().enumerate() { - let upvar_id = ty::UpvarId { var_id: freevar.def.node_id(), + let upvar_id = ty::UpvarId { var_id: freevar.def.var_id(), closure_expr_id: bcx.fcx.id }; let upvar_capture = bcx.tcx().upvar_capture(upvar_id).unwrap(); let mut upvar_ptr = StructGEP(bcx, llenv, i); @@ -79,7 +79,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, true } }; - let node_id = freevar.def.node_id(); + let node_id = freevar.def.var_id(); bcx.fcx.llupvars.borrow_mut().insert(node_id, upvar_ptr); if kind == ty::FnOnceClosureKind && !captured_by_ref { @@ -236,7 +236,7 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, for (i, freevar) in freevars.iter().enumerate() { let datum = expr::trans_local_var(bcx, freevar.def); let upvar_slot_dest = adt::trans_field_ptr(bcx, &*repr, dest_addr, 0, i); - let upvar_id = ty::UpvarId { var_id: freevar.def.node_id(), + let upvar_id = ty::UpvarId { var_id: freevar.def.var_id(), closure_expr_id: id }; match tcx.upvar_capture(upvar_id).unwrap() { ty::UpvarCapture::ByValue => { diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index 0024b51ae0f91..8086c49c769a8 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -126,7 +126,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { self.tcx().with_freevars(expr.id, |freevars| { for freevar in freevars { - let var_node_id = freevar.def.node_id(); + let var_node_id = freevar.def.var_id(); let upvar_id = ty::UpvarId { var_id: var_node_id, closure_expr_id: expr.id }; debug!("seed upvar_id {:?}", upvar_id); @@ -235,7 +235,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> { tcx.with_freevars(closure_id, |freevars| { freevars.iter() .map(|freevar| { - let freevar_node_id = freevar.def.node_id(); + let freevar_node_id = freevar.def.var_id(); let freevar_ty = self.fcx.node_ty(freevar_node_id); let upvar_id = ty::UpvarId { var_id: freevar_node_id, From cb784b70ba13b0bac334e7d39cb7917fce24b6ff Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 7 Sep 2015 14:13:35 -0400 Subject: [PATCH 07/17] Remove DefRegion, which is not used --- src/librustc/middle/astencode.rs | 1 - src/librustc/middle/def.rs | 4 +--- src/librustc/middle/mem_categorization.rs | 2 +- src/librustc_resolve/build_reduced_graph.rs | 2 +- src/librustc_trans/save/dump_csv.rs | 1 - src/librustc_trans/trans/callee.rs | 4 ++-- src/librustc_typeck/check/mod.rs | 2 -- 7 files changed, 5 insertions(+), 11 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 6125b7897723c..69c9896c09b41 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -476,7 +476,6 @@ impl tr for def::Def { def::DefUpvar(dcx.tr_id(nid1), index, dcx.tr_id(nid2)) } def::DefStruct(did) => def::DefStruct(did.tr(dcx)), - def::DefRegion(nid) => def::DefRegion(dcx.tr_id(nid)), def::DefLabel(nid) => def::DefLabel(dcx.tr_id(nid)) } } diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index ee1319a325e42..d87d45fdd964f 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -50,7 +50,6 @@ pub enum Def { /// - If it's an ExprPath referring to some tuple struct, then DefMap maps /// it to a def whose id is the StructDef.ctor_id. DefStruct(DefId), - DefRegion(ast::NodeId), DefLabel(ast::NodeId), DefMethod(DefId), } @@ -125,7 +124,7 @@ impl Def { DefVariant(..) | DefTy(..) | DefAssociatedTy(..) | DefTyParam(..) | DefUse(..) | DefStruct(..) | DefTrait(..) | DefMethod(..) | DefConst(..) | DefAssociatedConst(..) | - DefPrimTy(..) | DefRegion(..) | DefLabel(..) | DefSelfTy(..) => { + DefPrimTy(..) | DefLabel(..) | DefSelfTy(..) => { panic!("attempted .def_id() on invalid {:?}", self) } } @@ -143,7 +142,6 @@ impl Def { DefLocal(id) | DefUpvar(id, _, _) | - DefRegion(id) | DefLabel(id) | DefSelfTy(_, Some((_, id))) => { DefId::xxx_local(id) // TODO, clearly diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2e7d9e8982443..34b66ccded01e 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -551,7 +551,7 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> { } def::DefMod(_) | def::DefForeignMod(_) | def::DefUse(_) | def::DefTrait(_) | def::DefTy(..) | def::DefPrimTy(_) | - def::DefTyParam(..) | def::DefRegion(_) | + def::DefTyParam(..) | def::DefLabel(_) | def::DefSelfTy(..) | def::DefAssociatedTy(..) => { Ok(Rc::new(cmt_ { diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 3a53c8b4d8c6c..c50cb5960b1ff 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -816,7 +816,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { self.structs.insert(def_id, fields); } DefLocal(..) | DefPrimTy(..) | DefTyParam(..) | - DefUse(..) | DefUpvar(..) | DefRegion(..) | + DefUse(..) | DefUpvar(..) | DefLabel(..) | DefSelfTy(..) => { panic!("didn't expect `{:?}`", def); } diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 6c53762c3ead7..9750a81d810e3 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -264,7 +264,6 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { def::DefFn(..) => Some(recorder::FnRef), def::DefSelfTy(..) | - def::DefRegion(_) | def::DefLabel(_) | def::DefTyParam(..) | def::DefUse(_) | diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index df9dd8feafa75..b806f36b9109f 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -215,8 +215,8 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &hir::Expr) } def::DefMod(..) | def::DefForeignMod(..) | def::DefTrait(..) | def::DefTy(..) | def::DefPrimTy(..) | def::DefAssociatedTy(..) | - def::DefUse(..) | def::DefRegion(..) | def::DefLabel(..) | - def::DefTyParam(..) | def::DefSelfTy(..) => { + def::DefUse(..) | def::DefLabel(..) | def::DefTyParam(..) | + def::DefSelfTy(..) => { bcx.tcx().sess.span_bug( ref_expr.span, &format!("cannot translate def {:?} \ diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 7d4101fa243cb..639ff9ad0ba3f 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4318,7 +4318,6 @@ fn type_scheme_and_predicates_for_def<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, def::DefMod(..) | def::DefForeignMod(..) | def::DefUse(..) | - def::DefRegion(..) | def::DefLabel(..) | def::DefSelfTy(..) => { fcx.ccx.tcx.sess.span_bug(sp, &format!("expected value, found {:?}", defn)); @@ -4489,7 +4488,6 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, def::DefForeignMod(..) | def::DefLocal(..) | def::DefUse(..) | - def::DefRegion(..) | def::DefLabel(..) | def::DefUpvar(..) => { segment_spaces = vec![None; segments.len()]; From 95ce1ebe7c58915c3ac35ed790301739d3a4929d Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Mon, 7 Sep 2015 14:27:13 -0400 Subject: [PATCH 08/17] Move DefLabel out from the def_id() results --- src/librustc/middle/def.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index d87d45fdd964f..6c1fbfbdb2724 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -142,13 +142,15 @@ impl Def { DefLocal(id) | DefUpvar(id, _, _) | - DefLabel(id) | DefSelfTy(_, Some((_, id))) => { DefId::xxx_local(id) // TODO, clearly } - DefPrimTy(_) => panic!("attempted .def_id() on DefPrimTy"), - DefSelfTy(..) => panic!("attempted .def_id() on invalid DefSelfTy"), + DefLabel(..) | + DefPrimTy(..) | + DefSelfTy(..) => { + panic!("attempted .def_id() on invalid def: {:?}", self) + } } } From 3b1399df2dbdcbe0e126e8b434536257ccf604e1 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 8 Sep 2015 10:08:30 -0400 Subject: [PATCH 09/17] Make calling def_id on a DefSelfTy an error; the previous defids that were returned, either the trait or the *self type itself*, were not particularly representative of what the Def is (a type parameter). Rewrite paths to handle this case specially, just as they handle the primitive case specifically. This entire `def_id` codepath is kind of a mess. --- src/librustc/middle/dead.rs | 1 + src/librustc/middle/def.rs | 6 ++---- src/librustc/middle/stability.rs | 1 + src/librustc_privacy/lib.rs | 5 +++-- src/librustc_trans/save/dump_csv.rs | 3 ++- src/librustc_trans/save/mod.rs | 2 +- src/librustdoc/clean/mod.rs | 8 +++++++- 7 files changed, 17 insertions(+), 9 deletions(-) diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 994311efe79c5..6e31b733254bd 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -99,6 +99,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } _ if self.ignore_non_const_paths => (), def::DefPrimTy(_) => (), + def::DefSelfTy(..) => (), def::DefVariant(enum_id, variant_id, _) => { self.check_def_id(enum_id); if !self.ignore_variant_stack.contains(&variant_id) { diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index 6c1fbfbdb2724..3898d52615316 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -135,14 +135,12 @@ impl Def { DefFn(id, _) | DefMod(id) | DefForeignMod(id) | DefStatic(id, _) | DefVariant(_, id, _) | DefTy(id, _) | DefAssociatedTy(_, id) | DefTyParam(_, _, id, _) | DefUse(id) | DefStruct(id) | DefTrait(id) | - DefMethod(id) | DefConst(id) | DefAssociatedConst(id) | - DefSelfTy(Some(id), None)=> { + DefMethod(id) | DefConst(id) | DefAssociatedConst(id) => { id } DefLocal(id) | - DefUpvar(id, _, _) | - DefSelfTy(_, Some((_, id))) => { + DefUpvar(id, _, _) => { DefId::xxx_local(id) // TODO, clearly } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 15a7dd426fbbe..73519b8f579d5 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -474,6 +474,7 @@ pub fn check_path(tcx: &ty::ctxt, path: &hir::Path, id: ast::NodeId, cb: &mut FnMut(DefId, Span, &Option<&Stability>)) { match tcx.def_map.borrow().get(&id).map(|d| d.full_def()) { Some(def::DefPrimTy(..)) => {} + Some(def::DefSelfTy(..)) => {} Some(def) => { maybe_do_stability_check(tcx, def.def_id(), path.span, cb); } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 13b9b16e6ca45..ca5411f9c790a 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -263,6 +263,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { hir::TyPath(..) => { match self.tcx.def_map.borrow().get(&ty.id).unwrap().full_def() { def::DefPrimTy(..) => true, + def::DefSelfTy(..) => true, def => { let did = def.def_id(); if let Some(node_id) = self.tcx.map.as_local_node_id(did) { @@ -337,7 +338,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { hir::ItemTy(ref ty, _) if public_first => { if let hir::TyPath(..) = ty.node { match self.tcx.def_map.borrow().get(&ty.id).unwrap().full_def() { - def::DefPrimTy(..) | def::DefTyParam(..) => {}, + def::DefPrimTy(..) | def::DefSelfTy(..) | def::DefTyParam(..) => {}, def => { let did = def.def_id(); if let Some(node_id) = self.tcx.map.as_local_node_id(did) { @@ -1148,7 +1149,7 @@ impl<'a, 'tcx> VisiblePrivateTypesVisitor<'a, 'tcx> { fn path_is_private_type(&self, path_id: ast::NodeId) -> bool { let did = match self.tcx.def_map.borrow().get(&path_id).map(|d| d.full_def()) { // `int` etc. (None doesn't seem to occur.) - None | Some(def::DefPrimTy(..)) => return false, + None | Some(def::DefPrimTy(..)) | Some(def::DefSelfTy(..)) => return false, Some(def) => def.def_id(), }; diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 9750a81d810e3..20cdd21ad02f6 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -235,7 +235,8 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { } let def = self.tcx.def_map.borrow().get(&ref_id).unwrap().full_def(); match def { - def::DefPrimTy(_) => None, + def::DefPrimTy(..) => None, + def::DefSelfTy(..) => None, _ => Some(def.def_id()), } } diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 9f963d54dc54f..00781bd27110a 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -637,7 +637,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { } let def = self.tcx.def_map.borrow().get(&ref_id).unwrap().full_def(); match def { - def::DefPrimTy(_) => None, + def::DefPrimTy(_) | def::DefSelfTy(..) => None, _ => Some(def.def_id()), } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 344008b904eb9..2b6a8f3fe5251 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2570,17 +2570,19 @@ fn name_from_pat(p: &hir::Pat) -> String { fn resolve_type(cx: &DocContext, path: Path, id: ast::NodeId) -> Type { + debug!("resolve_type({:?},{:?})", path, id); let tcx = match cx.tcx_opt() { Some(tcx) => tcx, // If we're extracting tests, this return value doesn't matter. None => return Primitive(Bool), }; - debug!("searching for {} in defmap", id); let def = match tcx.def_map.borrow().get(&id) { Some(k) => k.full_def(), None => panic!("unresolved id not in defmap") }; + debug!("resolve_type: def={:?}", def); + let is_generic = match def { def::DefPrimTy(p) => match p { hir::TyStr => return Primitive(Str), @@ -2610,6 +2612,8 @@ fn resolve_type(cx: &DocContext, } fn register_def(cx: &DocContext, def: def::Def) -> DefId { + debug!("register_def({:?})", def); + let (did, kind) = match def { def::DefFn(i, _) => (i, TypeFunction), def::DefTy(i, false) => (i, TypeTypedef), @@ -2619,6 +2623,8 @@ fn register_def(cx: &DocContext, def: def::Def) -> DefId { def::DefMod(i) => (i, TypeModule), def::DefStatic(i, _) => (i, TypeStatic), def::DefVariant(i, _, _) => (i, TypeEnum), + def::DefSelfTy(Some(def_id), _) => (def_id, TypeTrait), + def::DefSelfTy(_, Some((impl_id, _))) => return cx.map.local_def_id(impl_id), _ => return def.def_id() }; if did.is_local() { return did } From a0dc2d9a292189f1642f1d856203509a3019225b Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 9 Sep 2015 14:23:43 -0400 Subject: [PATCH 10/17] Introduce semi-duplicate DefIds into DefLocal/DefUpvar to remove use of xxx_local. --- src/librustc/middle/astencode.rs | 13 ++++++++++--- src/librustc/middle/check_const.rs | 2 +- src/librustc/middle/check_match.rs | 2 +- src/librustc/middle/def.rs | 18 ++++++++---------- src/librustc/middle/expr_use_visitor.rs | 8 +++----- src/librustc/middle/liveness.rs | 10 +++++----- src/librustc/middle/mem_categorization.rs | 4 ++-- src/librustc_lint/bad_style.rs | 2 +- src/librustc_lint/builtin.rs | 3 ++- src/librustc_mir/tcx/expr.rs | 4 ++-- src/librustc_resolve/lib.rs | 10 ++++++---- src/librustc_trans/save/dump_csv.rs | 6 +++--- src/librustc_trans/trans/_match.rs | 6 +++--- src/librustc_trans/trans/consts.rs | 2 +- src/librustc_trans/trans/expr.rs | 4 ++-- src/librustc_typeck/check/mod.rs | 2 +- 16 files changed, 51 insertions(+), 45 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 69c9896c09b41..0b72b0d954200 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -461,7 +461,11 @@ impl tr for def::Def { def::DefStatic(did, m) => { def::DefStatic(did.tr(dcx), m) } def::DefConst(did) => { def::DefConst(did.tr(dcx)) } def::DefAssociatedConst(did) => def::DefAssociatedConst(did.tr(dcx)), - def::DefLocal(nid) => { def::DefLocal(dcx.tr_id(nid)) } + def::DefLocal(_, nid) => { + let nid = dcx.tr_id(nid); + let did = dcx.tcx.map.local_def_id(nid); + def::DefLocal(did, nid) + } def::DefVariant(e_did, v_did, is_s) => { def::DefVariant(e_did.tr(dcx), v_did.tr(dcx), is_s) }, @@ -472,8 +476,11 @@ impl tr for def::Def { def::DefPrimTy(p) => def::DefPrimTy(p), def::DefTyParam(s, index, def_id, n) => def::DefTyParam(s, index, def_id.tr(dcx), n), def::DefUse(did) => def::DefUse(did.tr(dcx)), - def::DefUpvar(nid1, index, nid2) => { - def::DefUpvar(dcx.tr_id(nid1), index, dcx.tr_id(nid2)) + def::DefUpvar(_, nid1, index, nid2) => { + let nid1 = dcx.tr_id(nid1); + let nid2 = dcx.tr_id(nid2); + let did1 = dcx.tcx.map.local_def_id(nid1); + def::DefUpvar(did1, nid1, index, nid2) } def::DefStruct(did) => def::DefStruct(did.tr(dcx)), def::DefLabel(nid) => def::DefLabel(dcx.tr_id(nid)) diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index b5901762e30d7..15c56d23da203 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -659,7 +659,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, doesn't point to a constant"); } } - Some(def::DefLocal(_)) if v.mode == Mode::ConstFn => { + Some(def::DefLocal(..)) if v.mode == Mode::ConstFn => { // Sadly, we can't determine whether the types are zero-sized. v.add_qualif(ConstQualif::NOT_CONST | ConstQualif::NON_ZERO_SIZED); } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 40d7b63cff9bb..283c6264717f0 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -245,7 +245,7 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) let pat_ty = cx.tcx.pat_ty(p); if let ty::TyEnum(edef, _) = pat_ty.sty { let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def()); - if let Some(DefLocal(_)) = def { + if let Some(DefLocal(..)) = def { if edef.variants.iter().any(|variant| variant.name == ident.node.name && variant.kind() == VariantKind::Unit diff --git a/src/librustc/middle/def.rs b/src/librustc/middle/def.rs index 3898d52615316..3e8325b86121d 100644 --- a/src/librustc/middle/def.rs +++ b/src/librustc/middle/def.rs @@ -29,7 +29,8 @@ pub enum Def { DefStatic(DefId, bool /* is_mutbl */), DefConst(DefId), DefAssociatedConst(DefId), - DefLocal(ast::NodeId), + DefLocal(DefId, // def id of variable + ast::NodeId), // node id of variable DefVariant(DefId /* enum */, DefId /* variant */, bool /* is_structure */), DefTy(DefId, bool /* is_enum */), DefAssociatedTy(DefId /* trait */, DefId), @@ -37,7 +38,8 @@ pub enum Def { DefPrimTy(hir::PrimTy), DefTyParam(ParamSpace, u32, DefId, ast::Name), DefUse(DefId), - DefUpvar(ast::NodeId, // id of closed over local + DefUpvar(DefId, // def id of closed over local + ast::NodeId, // node id of closed over local usize, // index in the freevars list of the closure ast::NodeId), // expr node that creates the closure @@ -115,8 +117,8 @@ pub struct Export { impl Def { pub fn var_id(&self) -> ast::NodeId { match *self { - DefLocal(id) | - DefUpvar(id, _, _) => { + DefLocal(_, id) | + DefUpvar(_, id, _, _) => { id } @@ -135,15 +137,11 @@ impl Def { DefFn(id, _) | DefMod(id) | DefForeignMod(id) | DefStatic(id, _) | DefVariant(_, id, _) | DefTy(id, _) | DefAssociatedTy(_, id) | DefTyParam(_, _, id, _) | DefUse(id) | DefStruct(id) | DefTrait(id) | - DefMethod(id) | DefConst(id) | DefAssociatedConst(id) => { + DefMethod(id) | DefConst(id) | DefAssociatedConst(id) | + DefLocal(id, _) | DefUpvar(id, _, _, _) => { id } - DefLocal(id) | - DefUpvar(id, _, _) => { - DefId::xxx_local(id) // TODO, clearly - } - DefLabel(..) | DefPrimTy(..) | DefSelfTy(..) => { diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index e69b805e83340..512faa8f8b534 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -280,11 +280,9 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { typer: &'t infer::InferCtxt<'a, 'tcx>) -> ExprUseVisitor<'d,'t,'a,'tcx> where 'tcx:'a { - ExprUseVisitor { - typer: typer, - mc: mc::MemCategorizationContext::new(typer), - delegate: delegate, - } + let mc: mc::MemCategorizationContext<'t, 'a, 'tcx> = + mc::MemCategorizationContext::new(typer); + ExprUseVisitor { typer: typer, mc: mc, delegate: delegate } } pub fn walk_fn(&mut self, diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index f3a3b5369511b..3b56597d353a3 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -465,7 +465,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) { let mut call_caps = Vec::new(); ir.tcx.with_freevars(expr.id, |freevars| { for fv in freevars { - if let DefLocal(rv) = fv.def { + if let DefLocal(_, rv) = fv.def { let fv_ln = ir.add_live_node(FreeVarNode(fv.span)); call_caps.push(CaptureInfo {ln: fv_ln, var_nid: rv}); @@ -1268,7 +1268,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { fn access_path(&mut self, expr: &Expr, succ: LiveNode, acc: u32) -> LiveNode { match self.ir.tcx.def_map.borrow().get(&expr.id).unwrap().full_def() { - DefLocal(nid) => { + DefLocal(_, nid) => { let ln = self.live_node(expr.id, expr.span); if acc != 0 { self.init_from_succ(ln, succ); @@ -1517,9 +1517,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { fn check_lvalue(&mut self, expr: &Expr) { match expr.node { hir::ExprPath(..) => { - if let DefLocal(nid) = self.ir.tcx.def_map.borrow().get(&expr.id) - .unwrap() - .full_def() { + if let DefLocal(_, nid) = self.ir.tcx.def_map.borrow().get(&expr.id) + .unwrap() + .full_def() { // Assignment to an immutable variable or argument: only legal // if there is no later assignment. If this local is actually // mutable, then check for a reassignment to flag the mutability diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 34b66ccded01e..555f864befbe0 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -575,7 +575,7 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> { })) } - def::DefUpvar(var_id, _, fn_node_id) => { + def::DefUpvar(_, var_id, _, fn_node_id) => { let ty = try!(self.node_ty(fn_node_id)); match ty.sty { ty::TyClosure(closure_id, _) => { @@ -600,7 +600,7 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> { } } - def::DefLocal(vid) => { + def::DefLocal(_, vid) => { Ok(Rc::new(cmt_ { id: id, span: span, diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index afa736d2220d3..91d1d398a0e54 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -274,7 +274,7 @@ impl LateLintPass for NonSnakeCase { fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) { if let &hir::PatIdent(_, ref path1, _) = &p.node { let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def()); - if let Some(def::DefLocal(_)) = def { + if let Some(def::DefLocal(..)) = def { self.check_snake_case(cx, "variable", &path1.node.name.as_str(), Some(p.span)); } } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index d4cf85d236f7a..8c5c4cce1674b 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -248,7 +248,8 @@ impl LateLintPass for NonShorthandFieldPatterns { return false; } let def = def_map.get(&fieldpat.node.pat.id).map(|d| d.full_def()); - def == Some(def::DefLocal(fieldpat.node.pat.id)) + let def_id = cx.tcx.map.local_def_id(fieldpat.node.pat.id); + def == Some(def::DefLocal(def_id, fieldpat.node.pat.id)) }); for fieldpat in field_pats { if let hir::PatIdent(_, ident, None) = fieldpat.node.pat.node { diff --git a/src/librustc_mir/tcx/expr.rs b/src/librustc_mir/tcx/expr.rs index 8cfcf1dd565c8..97becd474b1fe 100644 --- a/src/librustc_mir/tcx/expr.rs +++ b/src/librustc_mir/tcx/expr.rs @@ -569,13 +569,13 @@ fn convert_var<'a,'tcx:'a>(cx: &mut Cx<'a,'tcx>, let temp_lifetime = cx.tcx.region_maps.temporary_scope(expr.id); match def { - def::DefLocal(node_id) => { + def::DefLocal(_, node_id) => { ExprKind::VarRef { id: node_id, } } - def::DefUpvar(id_var, index, closure_expr_id) => { + def::DefUpvar(_, id_var, index, closure_expr_id) => { debug!("convert_var(upvar({:?}, {:?}, {:?}))", id_var, index, closure_expr_id); let var_ty = cx.tcx.node_id_to_type(id_var); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index e828c319a2b94..40477d8698ebe 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1982,7 +1982,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.session.span_bug(span, &format!("unexpected {:?} in bindings", def)) } - DefLocal(node_id) => { + DefLocal(_, node_id) => { for rib in ribs { match rib.kind { NormalRibKind => { @@ -1990,11 +1990,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } ClosureRibKind(function_id) => { let prev_def = def; + let node_def_id = self.ast_map.local_def_id(node_id); let mut seen = self.freevars_seen.borrow_mut(); let seen = seen.entry(function_id).or_insert_with(|| NodeMap()); if let Some(&index) = seen.get(&node_id) { - def = DefUpvar(node_id, index, function_id); + def = DefUpvar(node_def_id, node_id, index, function_id); continue; } let mut freevars = self.freevars.borrow_mut(); @@ -2003,7 +2004,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let depth = vec.len(); vec.push(Freevar { def: prev_def, span: span }); - def = DefUpvar(node_id, depth, function_id); + def = DefUpvar(node_def_id, node_id, depth, function_id); seen.insert(node_id, depth); } ItemRibKind | MethodRibKind => { @@ -2817,7 +2818,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { debug!("(resolving pattern) binding `{}`", renamed); - let def = DefLocal(pattern.id); + let def_id = self.ast_map.local_def_id(pattern.id); + let def = DefLocal(def_id, pattern.id); // Record the definition so that later passes // will be able to distinguish variants from diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 20cdd21ad02f6..dc0bdd8573d87 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -258,7 +258,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { def::DefStatic(_, _) | def::DefConst(_) | def::DefAssociatedConst(..) | - def::DefLocal(_) | + def::DefLocal(..) | def::DefVariant(_, _, _) | def::DefUpvar(..) => Some(recorder::VarRef), @@ -721,7 +721,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { } } } - def::DefLocal(_) | + def::DefLocal(..) | def::DefStatic(_,_) | def::DefConst(..) | def::DefAssociatedConst(..) | @@ -1170,7 +1170,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> { } let def = def_map.get(&id).unwrap().full_def(); match def { - def::DefLocal(id) => { + def::DefLocal(_, id) => { let value = if immut == ast::MutImmutable { self.span.snippet(p.span).to_string() } else { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 67bfe58089e85..1eb4a7a5e0c45 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -1432,19 +1432,19 @@ pub fn trans_match<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, fn is_discr_reassigned(bcx: Block, discr: &hir::Expr, body: &hir::Expr) -> bool { let (vid, field) = match discr.node { hir::ExprPath(..) => match bcx.def(discr.id) { - def::DefLocal(vid) | def::DefUpvar(vid, _, _) => (vid, None), + def::DefLocal(_, vid) | def::DefUpvar(_, vid, _, _) => (vid, None), _ => return false }, hir::ExprField(ref base, field) => { let vid = match bcx.tcx().def_map.borrow().get(&base.id).map(|d| d.full_def()) { - Some(def::DefLocal(vid)) | Some(def::DefUpvar(vid, _, _)) => vid, + Some(def::DefLocal(_, vid)) | Some(def::DefUpvar(_, vid, _, _)) => vid, _ => return false }; (vid, Some(mc::NamedField(field.node))) }, hir::ExprTupField(ref base, field) => { let vid = match bcx.tcx().def_map.borrow().get(&base.id).map(|d| d.full_def()) { - Some(def::DefLocal(vid)) | Some(def::DefUpvar(vid, _, _)) => vid, + Some(def::DefLocal(_, vid)) | Some(def::DefUpvar(_, vid, _, _)) => vid, _ => return false }; (vid, Some(mc::PositionalField(field.node))) diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index c7777c103e510..6aa087cce56bd 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -783,7 +783,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, hir::ExprPath(..) => { let def = cx.tcx().def_map.borrow().get(&e.id).unwrap().full_def(); match def { - def::DefLocal(id) => { + def::DefLocal(_, id) => { if let Some(val) = fn_args.and_then(|args| args.get(&id).cloned()) { val } else { diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 365caadeccbc4..476e05d50d20f 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -1358,7 +1358,7 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("trans_local_var"); match def { - def::DefUpvar(nid, _, _) => { + def::DefUpvar(_, nid, _, _) => { // Can't move upvars, so this is never a ZeroMemLastUse. let local_ty = node_id_type(bcx, nid); let lval = Lvalue::new_with_hint("expr::trans_local_var (upvar)", @@ -1372,7 +1372,7 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } } } - def::DefLocal(nid) => { + def::DefLocal(_, nid) => { let datum = match bcx.fcx.lllocals.borrow().get(&nid) { Some(&v) => v, None => { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 639ff9ad0ba3f..98836f0e5cf4c 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4300,7 +4300,7 @@ fn type_scheme_and_predicates_for_def<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, defn: def::Def) -> (TypeScheme<'tcx>, GenericPredicates<'tcx>) { match defn { - def::DefLocal(nid) | def::DefUpvar(nid, _, _) => { + def::DefLocal(_, nid) | def::DefUpvar(_, nid, _, _) => { let typ = fcx.local_ty(sp, nid); (ty::TypeScheme { generics: ty::Generics::empty(), ty: typ }, ty::GenericPredicates::empty()) From d7b0eb0f39861c47e2dce615197039e197417f17 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 10 Sep 2015 15:53:08 -0400 Subject: [PATCH 11/17] build up a set of node-ids that we can construct def-ids from --- src/librustc/front/map/collector.rs | 292 ++++++++++++++++++++++++++++ src/librustc/front/map/mod.rs | 258 +++++------------------- src/librustc/middle/astencode.rs | 38 ++-- src/librustc/util/ppaux.rs | 4 +- src/librustc_lint/builtin.rs | 7 +- src/librustdoc/clean/mod.rs | 2 +- src/librustdoc/visit_ast.rs | 7 +- 7 files changed, 371 insertions(+), 237 deletions(-) create mode 100644 src/librustc/front/map/collector.rs diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs new file mode 100644 index 0000000000000..0dd51b4ec8a5d --- /dev/null +++ b/src/librustc/front/map/collector.rs @@ -0,0 +1,292 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use super::*; +use super::MapEntry::*; + +use rustc_front::hir::*; +use rustc_front::util; +use rustc_front::visit::{self, Visitor}; +use std::iter::repeat; +use syntax::ast::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID}; +use syntax::codemap::Span; +use util::nodemap::NodeSet; + +/// A Visitor that walks over an AST and collects Node's into an AST +/// Map. +pub struct NodeCollector<'ast> { + pub map: Vec>, + pub definitions_map: NodeSet, + pub parent_node: NodeId, +} + +impl<'ast> NodeCollector<'ast> { + pub fn root() -> NodeCollector<'ast> { + let mut collector = NodeCollector { + map: vec![], + definitions_map: NodeSet(), + parent_node: CRATE_NODE_ID, + }; + collector.insert_entry(CRATE_NODE_ID, RootCrate); + collector.create_def(CRATE_NODE_ID); + collector.create_def(DUMMY_NODE_ID); + collector + } + + pub fn extend(parent: &'ast InlinedParent, + parent_node: NodeId, + map: Vec>, + definitions_map: NodeSet) + -> NodeCollector<'ast> { + let mut collector = NodeCollector { + map: map, + definitions_map: definitions_map, + parent_node: parent_node + }; + collector.insert_entry(parent_node, RootInlinedParent(parent)); + + collector + } + + fn create_def(&mut self, node: NodeId) { + let is_new = self.definitions_map.insert(node); + assert!(is_new, + "two entries for node id `{}` -- previous is `{:?}`", + node, node); + } + + fn insert_entry(&mut self, id: NodeId, entry: MapEntry<'ast>) { + debug!("ast_map: {:?} => {:?}", id, entry); + let len = self.map.len(); + if id as usize >= len { + self.map.extend(repeat(NotPresent).take(id as usize - len + 1)); + } + self.map[id as usize] = entry; + } + + fn insert(&mut self, id: NodeId, node: Node<'ast>) { + let entry = MapEntry::from_node(self.parent_node, node); + self.insert_entry(id, entry); + } + + fn visit_fn_decl(&mut self, decl: &'ast FnDecl) { + for a in &decl.inputs { + self.insert(a.id, NodeArg(&*a.pat)); + } + } +} + +impl<'ast> Visitor<'ast> for NodeCollector<'ast> { + fn visit_item(&mut self, i: &'ast Item) { + self.insert(i.id, NodeItem(i)); + + let parent_node = self.parent_node; + self.parent_node = i.id; + + self.create_def(i.id); + + match i.node { + ItemImpl(..) => { } + ItemEnum(ref enum_definition, _) => { + for v in &enum_definition.variants { + self.insert(v.node.id, NodeVariant(&**v)); + self.create_def(v.node.id); + + match v.node.kind { + TupleVariantKind(ref args) => { + for arg in args { + self.create_def(arg.id); + } + } + StructVariantKind(ref def) => { + for field in &def.fields { + self.create_def(field.node.id); + } + } + } + } + } + ItemForeignMod(..) => {} + ItemStruct(ref struct_def, _) => { + // If this is a tuple-like struct, register the constructor. + match struct_def.ctor_id { + Some(ctor_id) => { + self.insert(ctor_id, NodeStructCtor(&**struct_def)); + self.create_def(ctor_id); + } + None => {} + } + + for field in &struct_def.fields { + self.create_def(field.node.id); + } + } + ItemTrait(_, _, ref bounds, _) => { + for b in bounds.iter() { + if let TraitTyParamBound(ref t, TraitBoundModifier::None) = *b { + self.insert(t.trait_ref.ref_id, NodeItem(i)); + } + } + } + ItemUse(ref view_path) => { + match view_path.node { + ViewPathList(_, ref paths) => { + for path in paths { + self.insert(path.node.id(), NodeItem(i)); + } + } + _ => () + } + } + _ => {} + } + visit::walk_item(self, i); + self.parent_node = parent_node; + } + + fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) { + self.insert(foreign_item.id, NodeForeignItem(foreign_item)); + self.create_def(foreign_item.id); + + let parent_node = self.parent_node; + self.parent_node = foreign_item.id; + visit::walk_foreign_item(self, foreign_item); + self.parent_node = parent_node; + } + + fn visit_generics(&mut self, generics: &'ast Generics) { + for ty_param in generics.ty_params.iter() { + self.create_def(ty_param.id); + self.insert(ty_param.id, NodeTyParam(ty_param)); + } + + visit::walk_generics(self, generics); + } + + fn visit_trait_item(&mut self, ti: &'ast TraitItem) { + self.insert(ti.id, NodeTraitItem(ti)); + self.create_def(ti.id); + + match ti.node { + ConstTraitItem(_, Some(ref expr)) => { + self.create_def(expr.id); + } + _ => { } + } + + let parent_node = self.parent_node; + self.parent_node = ti.id; + visit::walk_trait_item(self, ti); + self.parent_node = parent_node; + } + + fn visit_impl_item(&mut self, ii: &'ast ImplItem) { + self.insert(ii.id, NodeImplItem(ii)); + self.create_def(ii.id); + + match ii.node { + ConstImplItem(_, ref expr) => { + self.create_def(expr.id); + } + _ => { } + } + + let parent_node = self.parent_node; + self.parent_node = ii.id; + visit::walk_impl_item(self, ii); + self.parent_node = parent_node; + } + + fn visit_pat(&mut self, pat: &'ast Pat) { + let maybe_binding = match pat.node { + PatIdent(..) => true, + _ => false + }; + + self.insert(pat.id, + if maybe_binding {NodeLocal(pat)} else {NodePat(pat)}); + + if maybe_binding { + self.create_def(pat.id); + } + + let parent_node = self.parent_node; + self.parent_node = pat.id; + visit::walk_pat(self, pat); + self.parent_node = parent_node; + } + + fn visit_expr(&mut self, expr: &'ast Expr) { + self.insert(expr.id, NodeExpr(expr)); + + match expr.node { + ExprClosure(..) => self.create_def(expr.id), + _ => (), + } + + let parent_node = self.parent_node; + self.parent_node = expr.id; + visit::walk_expr(self, expr); + self.parent_node = parent_node; + } + + fn visit_stmt(&mut self, stmt: &'ast Stmt) { + let id = util::stmt_id(stmt); + self.insert(id, NodeStmt(stmt)); + let parent_node = self.parent_node; + self.parent_node = id; + visit::walk_stmt(self, stmt); + self.parent_node = parent_node; + } + + fn visit_fn(&mut self, fk: visit::FnKind<'ast>, fd: &'ast FnDecl, + b: &'ast Block, s: Span, id: NodeId) { + let parent_node = self.parent_node; + self.parent_node = id; + self.visit_fn_decl(fd); + visit::walk_fn(self, fk, fd, b, s); + self.parent_node = parent_node; + } + + fn visit_ty(&mut self, ty: &'ast Ty) { + let parent_node = self.parent_node; + self.parent_node = ty.id; + match ty.node { + TyBareFn(ref fd) => { + self.visit_fn_decl(&*fd.decl); + } + _ => {} + } + visit::walk_ty(self, ty); + self.parent_node = parent_node; + } + + fn visit_block(&mut self, block: &'ast Block) { + self.insert(block.id, NodeBlock(block)); + let parent_node = self.parent_node; + self.parent_node = block.id; + visit::walk_block(self, block); + self.parent_node = parent_node; + } + + fn visit_lifetime(&mut self, lifetime: &'ast Lifetime) { + self.insert(lifetime.id, NodeLifetime(lifetime)); + } + + fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) { + self.create_def(def.lifetime.id); + self.visit_lifetime(&def.lifetime); + } + + fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) { + self.create_def(macro_def.id); + } +} + diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index b8d96cd3ba72b..0486fd3a0d1bb 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -11,32 +11,34 @@ pub use self::Node::*; pub use self::PathElem::*; use self::MapEntry::*; +use self::collector::NodeCollector; use metadata::cstore::LOCAL_CRATE; use metadata::inline::InlinedItem; use metadata::inline::InlinedItem as II; use middle::def_id::DefId; +use util::nodemap::NodeSet; use syntax::abi; -use syntax::ast::{self, Name, NodeId, CRATE_NODE_ID, DUMMY_NODE_ID}; +use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID}; use syntax::codemap::{Span, Spanned}; use syntax::parse::token; use rustc_front::hir::*; use rustc_front::fold::Folder; -use rustc_front::visit::{self, Visitor}; -use rustc_front::util; +use rustc_front::visit; use rustc_front::print::pprust; use arena::TypedArena; use std::cell::RefCell; use std::fmt; use std::io; -use std::iter::{self, repeat}; +use std::iter; use std::mem; use std::slice; pub mod blocks; +mod collector; #[derive(Clone, Copy, PartialEq, Debug)] pub enum PathElem { @@ -131,7 +133,7 @@ pub enum Node<'ast> { /// Represents an entry and its parent NodeID. /// The odd layout is to bring down the total size. #[derive(Copy, Debug)] -enum MapEntry<'ast> { +pub enum MapEntry<'ast> { /// Placeholder for holes in the map. NotPresent, @@ -264,22 +266,46 @@ pub struct Map<'ast> { /// /// Also, indexing is pretty quick when you've got a vector and /// plain old integers. - map: RefCell>> + map: RefCell>>, + + definitions_map: RefCell, } impl<'ast> Map<'ast> { pub fn local_def_id(&self, node: NodeId) -> DefId { - DefId::xxx_local(node) + self.opt_local_def_id(node).unwrap_or_else(|| { + panic!("local_def_id: no entry for `{}`, which has a map of `{:?}`", + node, self.find_entry(node)) + }) + } + + pub fn opt_local_def_id(&self, node: NodeId) -> Option { + if self.definitions_map.borrow().contains(&node) { + Some(DefId::xxx_local(node)) + } else { + None + } } pub fn as_local_node_id(&self, def_id: DefId) -> Option { if def_id.krate == LOCAL_CRATE { + assert!(self.definitions_map.borrow().contains(&def_id.xxx_node)); Some(def_id.xxx_node) } else { None } } + /// for default methods, we create a fake node-id; this method + /// adds that fake node-id to the def-id tables + pub fn synthesize_default_method_def_id(&self, + _impl_def_id: DefId, + new_method_id: NodeId) + -> DefId { + self.definitions_map.borrow_mut().insert(new_method_id); + DefId::xxx_local(new_method_id) + } + fn entry_count(&self) -> usize { self.map.borrow().len() } @@ -762,194 +788,10 @@ impl Folder for IdAndSpanUpdater { } } -/// A Visitor that walks over an AST and collects Node's into an AST Map. -struct NodeCollector<'ast> { - map: Vec>, - parent_node: NodeId, -} - -impl<'ast> NodeCollector<'ast> { - fn insert_entry(&mut self, id: NodeId, entry: MapEntry<'ast>) { - debug!("ast_map: {:?} => {:?}", id, entry); - let len = self.map.len(); - if id as usize >= len { - self.map.extend(repeat(NotPresent).take(id as usize - len + 1)); - } - self.map[id as usize] = entry; - } - - fn insert(&mut self, id: NodeId, node: Node<'ast>) { - let entry = MapEntry::from_node(self.parent_node, node); - self.insert_entry(id, entry); - } - - fn visit_fn_decl(&mut self, decl: &'ast FnDecl) { - for a in &decl.inputs { - self.insert(a.id, NodeArg(&*a.pat)); - } - } -} - -impl<'ast> Visitor<'ast> for NodeCollector<'ast> { - fn visit_item(&mut self, i: &'ast Item) { - self.insert(i.id, NodeItem(i)); - - let parent_node = self.parent_node; - self.parent_node = i.id; - - match i.node { - ItemImpl(_, _, _, _, _, ref impl_items) => { - for ii in impl_items { - self.insert(ii.id, NodeImplItem(ii)); - } - } - ItemEnum(ref enum_definition, _) => { - for v in &enum_definition.variants { - self.insert(v.node.id, NodeVariant(&**v)); - } - } - ItemForeignMod(ref nm) => { - for nitem in &nm.items { - self.insert(nitem.id, NodeForeignItem(&**nitem)); - } - } - ItemStruct(ref struct_def, _) => { - // If this is a tuple-like struct, register the constructor. - match struct_def.ctor_id { - Some(ctor_id) => { - self.insert(ctor_id, NodeStructCtor(&**struct_def)); - } - None => {} - } - } - ItemTrait(_, _, ref bounds, ref trait_items) => { - for b in bounds.iter() { - if let TraitTyParamBound(ref t, TraitBoundModifier::None) = *b { - self.insert(t.trait_ref.ref_id, NodeItem(i)); - } - } - - for ti in trait_items { - self.insert(ti.id, NodeTraitItem(ti)); - } - } - ItemUse(ref view_path) => { - match view_path.node { - ViewPathList(_, ref paths) => { - for path in paths { - self.insert(path.node.id(), NodeItem(i)); - } - } - _ => () - } - } - _ => {} - } - visit::walk_item(self, i); - self.parent_node = parent_node; - } - - fn visit_generics(&mut self, generics: &'ast Generics) { - for ty_param in generics.ty_params.iter() { - self.insert(ty_param.id, NodeTyParam(ty_param)); - } - - visit::walk_generics(self, generics); - } - - fn visit_trait_item(&mut self, ti: &'ast TraitItem) { - let parent_node = self.parent_node; - self.parent_node = ti.id; - visit::walk_trait_item(self, ti); - self.parent_node = parent_node; - } - - fn visit_impl_item(&mut self, ii: &'ast ImplItem) { - let parent_node = self.parent_node; - self.parent_node = ii.id; - - visit::walk_impl_item(self, ii); - - self.parent_node = parent_node; - } - - fn visit_pat(&mut self, pat: &'ast Pat) { - self.insert(pat.id, match pat.node { - // Note: this is at least *potentially* a pattern... - PatIdent(..) => NodeLocal(pat), - _ => NodePat(pat) - }); - - let parent_node = self.parent_node; - self.parent_node = pat.id; - visit::walk_pat(self, pat); - self.parent_node = parent_node; - } - - fn visit_expr(&mut self, expr: &'ast Expr) { - self.insert(expr.id, NodeExpr(expr)); - let parent_node = self.parent_node; - self.parent_node = expr.id; - visit::walk_expr(self, expr); - self.parent_node = parent_node; - } - - fn visit_stmt(&mut self, stmt: &'ast Stmt) { - let id = util::stmt_id(stmt); - self.insert(id, NodeStmt(stmt)); - let parent_node = self.parent_node; - self.parent_node = id; - visit::walk_stmt(self, stmt); - self.parent_node = parent_node; - } - - fn visit_fn(&mut self, fk: visit::FnKind<'ast>, fd: &'ast FnDecl, - b: &'ast Block, s: Span, id: NodeId) { - let parent_node = self.parent_node; - self.parent_node = id; - self.visit_fn_decl(fd); - visit::walk_fn(self, fk, fd, b, s); - self.parent_node = parent_node; - } - - fn visit_ty(&mut self, ty: &'ast Ty) { - let parent_node = self.parent_node; - self.parent_node = ty.id; - match ty.node { - TyBareFn(ref fd) => { - self.visit_fn_decl(&*fd.decl); - } - _ => {} - } - visit::walk_ty(self, ty); - self.parent_node = parent_node; - } - - fn visit_block(&mut self, block: &'ast Block) { - self.insert(block.id, NodeBlock(block)); - let parent_node = self.parent_node; - self.parent_node = block.id; - visit::walk_block(self, block); - self.parent_node = parent_node; - } - - fn visit_lifetime(&mut self, lifetime: &'ast Lifetime) { - self.insert(lifetime.id, NodeLifetime(lifetime)); - } - - fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) { - self.visit_lifetime(&def.lifetime); - } -} - pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> { - let mut collector = NodeCollector { - map: vec![], - parent_node: CRATE_NODE_ID, - }; - collector.insert_entry(CRATE_NODE_ID, RootCrate); + let mut collector = NodeCollector::root(); visit::walk_crate(&mut collector, &forest.krate); - let map = collector.map; + let NodeCollector { map, definitions_map, .. } = collector; if log_enabled!(::log::DEBUG) { // This only makes sense for ordered stores; note the @@ -969,7 +811,8 @@ pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> { Map { forest: forest, - map: RefCell::new(map) + map: RefCell::new(map), + definitions_map: RefCell::new(definitions_map), } } @@ -1001,29 +844,16 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>, }); let ii_parent_id = fld.new_id(DUMMY_NODE_ID); - let mut collector = NodeCollector { - map: mem::replace(&mut *map.map.borrow_mut(), vec![]), - parent_node: ii_parent_id, - }; - collector.insert_entry(ii_parent_id, RootInlinedParent(ii_parent)); + let mut collector = + NodeCollector::extend(ii_parent, + ii_parent_id, + mem::replace(&mut *map.map.borrow_mut(), vec![]), + mem::replace(&mut *map.definitions_map.borrow_mut(), NodeSet())); ii_parent.ii.visit(&mut collector); - // Methods get added to the AST map when their impl is visited. Since we - // don't decode and instantiate the impl, but just the method, we have to - // add it to the table now. Likewise with foreign items. - match ii_parent.ii { - II::Item(_) => {} - II::TraitItem(_, ref ti) => { - collector.insert(ti.id, NodeTraitItem(ti)); - } - II::ImplItem(_, ref ii) => { - collector.insert(ii.id, NodeImplItem(ii)); - } - II::Foreign(ref i) => { - collector.insert(i.id, NodeForeignItem(i)); - } - } *map.map.borrow_mut() = collector.map; + *map.definitions_map.borrow_mut() = collector.definitions_map; + &ii_parent.ii } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 0b72b0d954200..02bd9951d341a 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -957,12 +957,14 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } } - let lid = tcx.map.local_def_id(id); - if let Some(type_scheme) = tcx.tcache.borrow().get(&lid) { - rbml_w.tag(c::tag_table_tcache, |rbml_w| { - rbml_w.id(id); - rbml_w.emit_type_scheme(ecx, type_scheme.clone()); - }) + let opt_def_id = tcx.map.opt_local_def_id(id); + if let Some(lid) = opt_def_id { + if let Some(type_scheme) = tcx.tcache.borrow().get(&lid) { + rbml_w.tag(c::tag_table_tcache, |rbml_w| { + rbml_w.id(id); + rbml_w.emit_type_scheme(ecx, type_scheme.clone()); + }) + } } if let Some(type_param_def) = tcx.ty_param_defs.borrow().get(&id) { @@ -1003,18 +1005,22 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - if let Some(closure_type) = tcx.tables.borrow().closure_tys.get(&tcx.map.local_def_id(id)) { - rbml_w.tag(c::tag_table_closure_tys, |rbml_w| { - rbml_w.id(id); - rbml_w.emit_closure_type(ecx, closure_type); - }) + if let Some(def_id) = opt_def_id { + if let Some(closure_type) = tcx.tables.borrow().closure_tys.get(&def_id) { + rbml_w.tag(c::tag_table_closure_tys, |rbml_w| { + rbml_w.id(id); + rbml_w.emit_closure_type(ecx, closure_type); + }) + } } - if let Some(closure_kind) = tcx.tables.borrow().closure_kinds.get(&tcx.map.local_def_id(id)) { - rbml_w.tag(c::tag_table_closure_kinds, |rbml_w| { - rbml_w.id(id); - encode_closure_kind(rbml_w, *closure_kind) - }) + if let Some(def_id) = opt_def_id { + if let Some(closure_kind) = tcx.tables.borrow().closure_kinds.get(&def_id) { + rbml_w.tag(c::tag_table_closure_kinds, |rbml_w| { + rbml_w.id(id); + encode_closure_kind(rbml_w, *closure_kind) + }) + } } if let Some(cast_kind) = tcx.cast_kinds.borrow().get(&id) { diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index e4eba8aefcc49..de356e54699c1 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -27,7 +27,7 @@ use std::fmt; use syntax::abi; use syntax::ast; use syntax::parse::token; -use syntax::ast::DUMMY_NODE_ID; +use syntax::ast::{CRATE_NODE_ID}; use rustc_front::hir; pub fn verbose() -> bool { @@ -232,7 +232,7 @@ fn in_binder<'tcx, T, U>(f: &mut fmt::Formatter, ty::BrEnv => { let name = token::intern("'r"); let _ = write!(f, "{}", name); - ty::BrNamed(tcx.map.local_def_id(DUMMY_NODE_ID), name) + ty::BrNamed(tcx.map.local_def_id(CRATE_NODE_ID), name) } }) }).0; diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 8c5c4cce1674b..d05b5b3e8606a 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -248,8 +248,11 @@ impl LateLintPass for NonShorthandFieldPatterns { return false; } let def = def_map.get(&fieldpat.node.pat.id).map(|d| d.full_def()); - let def_id = cx.tcx.map.local_def_id(fieldpat.node.pat.id); - def == Some(def::DefLocal(def_id, fieldpat.node.pat.id)) + if let Some(def_id) = cx.tcx.map.opt_local_def_id(fieldpat.node.pat.id) { + def == Some(def::DefLocal(def_id, fieldpat.node.pat.id)) + } else { + false + } }); for fieldpat in field_pats { if let hir::PatIdent(_, ident, None) = fieldpat.node.pat.node { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 2b6a8f3fe5251..dab4056b4af81 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -188,7 +188,7 @@ impl<'a, 'tcx> Clean for visit_ast::RustdocVisitor<'a, 'tcx> { attrs: child.attrs.clone(), visibility: Some(hir::Public), stability: None, - def_id: cx.map.local_def_id(prim.to_node_id()), + def_id: DefId::xxx_local(prim.to_node_id()), inner: PrimitiveItem(prim), }); } diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 9972ede8b8f9f..264656835a384 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -62,8 +62,11 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { } fn stability(&self, id: ast::NodeId) -> Option { - self.cx.tcx_opt().and_then( - |tcx| stability::lookup(tcx, self.cx.map.local_def_id(id)).map(|x| x.clone())) + self.cx.tcx_opt().and_then(|tcx| { + self.cx.map.opt_local_def_id(id) + .and_then(|def_id| stability::lookup(tcx, def_id)) + .cloned() + }) } pub fn visit(&mut self, krate: &hir::Crate) { From 34a25db45f68aa96f1231589f01bdda96a77562a Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 29 Sep 2015 06:47:33 -0400 Subject: [PATCH 12/17] stop updating `parent_node_id` when there is no corresponding map entry --- src/librustc/front/map/collector.rs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index 0dd51b4ec8a5d..a252992812ebb 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -248,16 +248,12 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { fn visit_fn(&mut self, fk: visit::FnKind<'ast>, fd: &'ast FnDecl, b: &'ast Block, s: Span, id: NodeId) { - let parent_node = self.parent_node; - self.parent_node = id; + assert_eq!(self.parent_node, id); self.visit_fn_decl(fd); visit::walk_fn(self, fk, fd, b, s); - self.parent_node = parent_node; } fn visit_ty(&mut self, ty: &'ast Ty) { - let parent_node = self.parent_node; - self.parent_node = ty.id; match ty.node { TyBareFn(ref fd) => { self.visit_fn_decl(&*fd.decl); @@ -265,7 +261,6 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { _ => {} } visit::walk_ty(self, ty); - self.parent_node = parent_node; } fn visit_block(&mut self, block: &'ast Block) { From a6fee0674171fefc25e1a61e01870a654d6862a8 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 11 Sep 2015 11:29:17 -0400 Subject: [PATCH 13/17] rename ast_map to hir_map --- src/librustc/metadata/decoder.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 54a815b454aac..8ce31e533de82 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -15,7 +15,7 @@ pub use self::DefLike::*; use self::Family::*; -use front::map as ast_map; +use front::map as hir_map; use rustc_front::hir; use back::svh::Svh; @@ -241,15 +241,15 @@ fn item_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) doc_trait_ref(tp, tcx, cdata) } -fn item_path(item_doc: rbml::Doc) -> Vec { +fn item_path(item_doc: rbml::Doc) -> Vec { let path_doc = reader::get_doc(item_doc, tag_path); reader::docs(path_doc).filter_map(|(tag, elt_doc)| { if tag == tag_path_elem_mod { let s = elt_doc.as_str_slice(); - Some(ast_map::PathMod(token::intern(s))) + Some(hir_map::PathMod(token::intern(s))) } else if tag == tag_path_elem_name { let s = elt_doc.as_str_slice(); - Some(ast_map::PathName(token::intern(s))) + Some(hir_map::PathName(token::intern(s))) } else { // ignore tag_path_len element None @@ -745,7 +745,7 @@ pub fn each_top_level_item_of_crate(intr: Rc, callback) } -pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec { +pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec { item_path(cdata.lookup_item(id)) } @@ -756,9 +756,9 @@ pub fn get_item_name(intr: &IdentInterner, cdata: Cmd, id: ast::NodeId) -> ast:: pub type DecodeInlinedItem<'a> = Box FnMut(Cmd, &ty::ctxt<'tcx>, - Vec, + Vec, rbml::Doc) - -> Result<&'tcx InlinedItem, Vec> + 'a>; + -> Result<&'tcx InlinedItem, Vec> + 'a>; pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: ast::NodeId, mut decode_inlined_item: DecodeInlinedItem) From 01f32ace0302373fb69ef9e2d0e21cc841981eba Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 17 Sep 2015 14:29:59 -0400 Subject: [PATCH 14/17] Convert DefId to use DefIndex, which is an index into a list of paths, and construct paths for all definitions. Also, stop rewriting DefIds for closures, and instead just load the closure data from the original def-id, which may be in another crate. --- src/librustc/front/map/collector.rs | 163 +++++++---- src/librustc/front/map/definitions.rs | 263 ++++++++++++++++++ src/librustc/front/map/mod.rs | 68 +++-- src/librustc/metadata/common.rs | 19 +- src/librustc/metadata/creader.rs | 7 +- src/librustc/metadata/csearch.rs | 103 ++++--- src/librustc/metadata/cstore.rs | 18 ++ src/librustc/metadata/decoder.rs | 222 +++++++++------ src/librustc/metadata/encoder.rs | 248 +++++++++-------- src/librustc/metadata/index.rs | 224 +++++---------- src/librustc/metadata/tydecode.rs | 64 ++--- src/librustc/middle/astencode.rs | 114 +------- src/librustc/middle/const_eval.rs | 6 +- src/librustc/middle/def_id.rs | 45 ++- src/librustc/middle/expr_use_visitor.rs | 2 +- src/librustc/middle/infer/mod.rs | 21 +- src/librustc/middle/lang_items.rs | 4 +- src/librustc/middle/stability.rs | 4 +- src/librustc/middle/traits/select.rs | 7 +- src/librustc/middle/ty/context.rs | 48 +++- src/librustc/middle/ty/mod.rs | 21 ++ src/librustc/middle/ty/util.rs | 2 +- src/librustc/util/ppaux.rs | 2 +- src/librustc_lint/builtin.rs | 22 +- src/librustc_resolve/build_reduced_graph.rs | 4 +- src/librustc_trans/back/link.rs | 29 +- src/librustc_trans/save/recorder.rs | 37 ++- src/librustc_trans/trans/base.rs | 9 +- src/librustc_trans/trans/closure.rs | 35 +-- src/librustc_trans/trans/common.rs | 7 +- src/librustc_trans/trans/consts.rs | 4 +- .../trans/debuginfo/metadata.rs | 2 +- src/librustc_trans/trans/expr.rs | 15 +- src/librustc_trans/trans/foreign.rs | 12 +- src/librustc_trans/trans/inline.rs | 2 +- src/librustc_trans/trans/monomorphize.rs | 7 +- src/librustdoc/clean/mod.rs | 11 +- src/librustdoc/html/format.rs | 5 +- src/librustdoc/html/render.rs | 16 +- src/libsyntax/ast.rs | 4 +- 40 files changed, 1119 insertions(+), 777 deletions(-) create mode 100644 src/librustc/front/map/definitions.rs diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs index a252992812ebb..5f3148c7c33c5 100644 --- a/src/librustc/front/map/collector.rs +++ b/src/librustc/front/map/collector.rs @@ -14,16 +14,16 @@ use super::MapEntry::*; use rustc_front::hir::*; use rustc_front::util; use rustc_front::visit::{self, Visitor}; +use middle::def_id::{CRATE_DEF_INDEX, DefIndex}; use std::iter::repeat; use syntax::ast::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID}; use syntax::codemap::Span; -use util::nodemap::NodeSet; /// A Visitor that walks over an AST and collects Node's into an AST /// Map. pub struct NodeCollector<'ast> { pub map: Vec>, - pub definitions_map: NodeSet, + pub definitions: Definitions, pub parent_node: NodeId, } @@ -31,35 +31,59 @@ impl<'ast> NodeCollector<'ast> { pub fn root() -> NodeCollector<'ast> { let mut collector = NodeCollector { map: vec![], - definitions_map: NodeSet(), + definitions: Definitions::new(), parent_node: CRATE_NODE_ID, }; collector.insert_entry(CRATE_NODE_ID, RootCrate); - collector.create_def(CRATE_NODE_ID); - collector.create_def(DUMMY_NODE_ID); + + let result = collector.create_def_with_parent(None, CRATE_NODE_ID, DefPathData::CrateRoot); + assert_eq!(result, CRATE_DEF_INDEX); + + collector.create_def_with_parent(Some(CRATE_DEF_INDEX), DUMMY_NODE_ID, DefPathData::Misc); + collector } pub fn extend(parent: &'ast InlinedParent, parent_node: NodeId, + parent_def_path: DefPath, map: Vec>, - definitions_map: NodeSet) + definitions: Definitions) -> NodeCollector<'ast> { let mut collector = NodeCollector { map: map, - definitions_map: definitions_map, - parent_node: parent_node + parent_node: parent_node, + definitions: definitions, }; + collector.insert_entry(parent_node, RootInlinedParent(parent)); + collector.create_def(parent_node, DefPathData::InlinedRoot(parent_def_path)); collector } - fn create_def(&mut self, node: NodeId) { - let is_new = self.definitions_map.insert(node); - assert!(is_new, - "two entries for node id `{}` -- previous is `{:?}`", - node, node); + fn parent_def(&self) -> Option { + let mut parent_node = Some(self.parent_node); + while let Some(p) = parent_node { + if let Some(q) = self.definitions.opt_def_index(p) { + return Some(q); + } + parent_node = self.map[p as usize].parent_node(); + } + None + } + + fn create_def(&mut self, node_id: NodeId, data: DefPathData) -> DefIndex { + let parent_def = self.parent_def(); + self.definitions.create_def_with_parent(parent_def, node_id, data) + } + + fn create_def_with_parent(&mut self, + parent: Option, + node_id: NodeId, + data: DefPathData) + -> DefIndex { + self.definitions.create_def_with_parent(parent, node_id, data) } fn insert_entry(&mut self, id: NodeId, entry: MapEntry<'ast>) { @@ -71,6 +95,11 @@ impl<'ast> NodeCollector<'ast> { self.map[id as usize] = entry; } + fn insert_def(&mut self, id: NodeId, node: Node<'ast>, data: DefPathData) -> DefIndex { + self.insert(id, node); + self.create_def(id, data) + } + fn insert(&mut self, id: NodeId, node: Node<'ast>) { let entry = MapEntry::from_node(self.parent_node, node); self.insert_entry(id, entry); @@ -85,47 +114,61 @@ impl<'ast> NodeCollector<'ast> { impl<'ast> Visitor<'ast> for NodeCollector<'ast> { fn visit_item(&mut self, i: &'ast Item) { - self.insert(i.id, NodeItem(i)); + // Pick the def data. This need not be unique, but the more + // information we encapsulate into + let def_data = match i.node { + ItemDefaultImpl(..) | ItemImpl(..) => DefPathData::Impl, + ItemEnum(..) | ItemStruct(..) | ItemTrait(..) => DefPathData::Type(i.name), + ItemExternCrate(..) | ItemMod(..) => DefPathData::Mod(i.name), + ItemStatic(..) | ItemConst(..) | ItemFn(..) => DefPathData::Value(i.name), + _ => DefPathData::Misc, + }; + + self.insert_def(i.id, NodeItem(i), def_data); let parent_node = self.parent_node; self.parent_node = i.id; - self.create_def(i.id); - match i.node { - ItemImpl(..) => { } + ItemImpl(..) => {} ItemEnum(ref enum_definition, _) => { for v in &enum_definition.variants { - self.insert(v.node.id, NodeVariant(&**v)); - self.create_def(v.node.id); + let variant_def_index = + self.insert_def(v.node.id, + NodeVariant(&**v), + DefPathData::EnumVariant(v.node.name)); match v.node.kind { TupleVariantKind(ref args) => { for arg in args { - self.create_def(arg.id); + self.create_def_with_parent(Some(variant_def_index), + arg.id, + DefPathData::PositionalField); } } StructVariantKind(ref def) => { for field in &def.fields { - self.create_def(field.node.id); + self.create_def_with_parent( + Some(variant_def_index), + field.node.id, + DefPathData::Field(field.node.kind)); } } } } } - ItemForeignMod(..) => {} + ItemForeignMod(..) => { + } ItemStruct(ref struct_def, _) => { // If this is a tuple-like struct, register the constructor. - match struct_def.ctor_id { - Some(ctor_id) => { - self.insert(ctor_id, NodeStructCtor(&**struct_def)); - self.create_def(ctor_id); - } - None => {} + if let Some(ctor_id) = struct_def.ctor_id { + self.insert_def(ctor_id, + NodeStructCtor(&**struct_def), + DefPathData::StructCtor); } for field in &struct_def.fields { - self.create_def(field.node.id); + self.create_def(field.node.id, DefPathData::Field(field.node.kind)); } } ItemTrait(_, _, ref bounds, _) => { @@ -152,8 +195,9 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { } fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) { - self.insert(foreign_item.id, NodeForeignItem(foreign_item)); - self.create_def(foreign_item.id); + self.insert_def(foreign_item.id, + NodeForeignItem(foreign_item), + DefPathData::Value(foreign_item.name)); let parent_node = self.parent_node; self.parent_node = foreign_item.id; @@ -163,58 +207,71 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { fn visit_generics(&mut self, generics: &'ast Generics) { for ty_param in generics.ty_params.iter() { - self.create_def(ty_param.id); - self.insert(ty_param.id, NodeTyParam(ty_param)); + self.insert_def(ty_param.id, + NodeTyParam(ty_param), + DefPathData::TypeParam(ty_param.name)); } visit::walk_generics(self, generics); } fn visit_trait_item(&mut self, ti: &'ast TraitItem) { + let def_data = match ti.node { + MethodTraitItem(..) | ConstTraitItem(..) => DefPathData::Value(ti.name), + TypeTraitItem(..) => DefPathData::Type(ti.name), + }; + self.insert(ti.id, NodeTraitItem(ti)); - self.create_def(ti.id); + self.create_def(ti.id, def_data); + + let parent_node = self.parent_node; + self.parent_node = ti.id; match ti.node { ConstTraitItem(_, Some(ref expr)) => { - self.create_def(expr.id); + self.create_def(expr.id, DefPathData::Initializer); } _ => { } } - let parent_node = self.parent_node; - self.parent_node = ti.id; visit::walk_trait_item(self, ti); + self.parent_node = parent_node; } fn visit_impl_item(&mut self, ii: &'ast ImplItem) { - self.insert(ii.id, NodeImplItem(ii)); - self.create_def(ii.id); + let def_data = match ii.node { + MethodImplItem(..) | ConstImplItem(..) => DefPathData::Value(ii.name), + TypeImplItem(..) => DefPathData::Type(ii.name), + }; + + self.insert_def(ii.id, NodeImplItem(ii), def_data); + + let parent_node = self.parent_node; + self.parent_node = ii.id; match ii.node { ConstImplItem(_, ref expr) => { - self.create_def(expr.id); + self.create_def(expr.id, DefPathData::Initializer); } _ => { } } - let parent_node = self.parent_node; - self.parent_node = ii.id; visit::walk_impl_item(self, ii); + self.parent_node = parent_node; } fn visit_pat(&mut self, pat: &'ast Pat) { let maybe_binding = match pat.node { - PatIdent(..) => true, - _ => false + PatIdent(_, id, _) => Some(id.node), + _ => None }; - self.insert(pat.id, - if maybe_binding {NodeLocal(pat)} else {NodePat(pat)}); - - if maybe_binding { - self.create_def(pat.id); + if let Some(id) = maybe_binding { + self.insert_def(pat.id, NodeLocal(pat), DefPathData::Binding(id.name)); + } else { + self.insert(pat.id, NodePat(pat)); } let parent_node = self.parent_node; @@ -227,8 +284,8 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { self.insert(expr.id, NodeExpr(expr)); match expr.node { - ExprClosure(..) => self.create_def(expr.id), - _ => (), + ExprClosure(..) => { self.create_def(expr.id, DefPathData::ClosureExpr); } + _ => { } } let parent_node = self.parent_node; @@ -276,12 +333,12 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> { } fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) { - self.create_def(def.lifetime.id); + self.create_def(def.lifetime.id, DefPathData::LifetimeDef(def.lifetime.name)); self.visit_lifetime(&def.lifetime); } fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) { - self.create_def(macro_def.id); + self.create_def(macro_def.id, DefPathData::MacroDef(macro_def.name)); } } diff --git a/src/librustc/front/map/definitions.rs b/src/librustc/front/map/definitions.rs new file mode 100644 index 0000000000000..c1eb5f1f11845 --- /dev/null +++ b/src/librustc/front/map/definitions.rs @@ -0,0 +1,263 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::{DefId, DefIndex}; +use rustc_data_structures::fnv::FnvHashMap; +use rustc_front::hir; +use syntax::ast; +use syntax::parse::token::InternedString; +use util::nodemap::NodeMap; + +#[derive(Clone)] +pub struct Definitions { + data: Vec, + key_map: FnvHashMap, + node_map: NodeMap, +} + +/// A unique identifier that we can use to lookup a definition +/// precisely. It combines the index of the definition's parent (if +/// any) with a `DisambiguatedDefPathData`. +#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +pub struct DefKey { + /// Parent path. + pub parent: Option, + + /// Identifier of this node. + pub disambiguated_data: DisambiguatedDefPathData, +} + +/// Pair of `DefPathData` and an integer disambiguator. The integer is +/// normally 0, but in the event that there are multiple defs with the +/// same `parent` and `data`, we use this field to disambiguate +/// between them. This introduces some artificial ordering dependency +/// but means that if you have (e.g.) two impls for the same type in +/// the same module, they do get distinct def-ids. +#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +pub struct DisambiguatedDefPathData { + pub data: DefPathData, + pub disambiguator: u32 +} + +/// For each definition, we track the following data. A definition +/// here is defined somewhat circularly as "something with a def-id", +/// but it generally corresponds to things like structs, enums, etc. +/// There are also some rather random cases (like const initializer +/// expressions) that are mostly just leftovers. +#[derive(Clone, Debug)] +pub struct DefData { + pub key: DefKey, + + /// Local ID within the HIR. + pub node_id: ast::NodeId, +} + +pub type DefPath = Vec; + +#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +pub enum DefPathData { + // Root: these should only be used for the root nodes, because + // they are treated specially by the `def_path` function. + CrateRoot, + InlinedRoot(DefPath), + + // Catch-all for random DefId things like DUMMY_NODE_ID + Misc, + + // Different kinds of items and item-like things: + Impl, + Type(ast::Name), + Mod(ast::Name), + Value(ast::Name), + MacroDef(ast::Name), + ClosureExpr, + + // Subportions of items + TypeParam(ast::Name), + LifetimeDef(ast::Name), + EnumVariant(ast::Name), + PositionalField, + Field(hir::StructFieldKind), + StructCtor, // implicit ctor for a tuple-like struct + Initializer, // initializer for a const + Binding(ast::Name), // pattern binding + + // An external crate that does not have an `extern crate` in this + // crate. + DetachedCrate(ast::Name), +} + +impl Definitions { + pub fn new() -> Definitions { + Definitions { + data: vec![], + key_map: FnvHashMap(), + node_map: NodeMap(), + } + } + + pub fn len(&self) -> usize { + self.data.len() + } + + pub fn def_key(&self, index: DefIndex) -> DefKey { + self.data[index.as_usize()].key.clone() + } + + /// Returns the path from the crate root to `index`. The root + /// nodes are not included in the path (i.e., this will be an + /// empty vector for the crate root). For an inlined item, this + /// will be the path of the item in the external crate (but the + /// path will begin with the path to the external crate). + pub fn def_path(&self, index: DefIndex) -> DefPath { + make_def_path(index, |p| self.def_key(p)) + } + + pub fn opt_def_index(&self, node: ast::NodeId) -> Option { + self.node_map.get(&node).cloned() + } + + pub fn opt_local_def_id(&self, node: ast::NodeId) -> Option { + self.opt_def_index(node).map(DefId::local) + } + + pub fn as_local_node_id(&self, def_id: DefId) -> Option { + if def_id.krate == LOCAL_CRATE { + assert!(def_id.index.as_usize() < self.data.len()); + Some(self.data[def_id.index.as_usize()].node_id) + } else { + None + } + } + + pub fn create_def_with_parent(&mut self, + parent: Option, + node_id: ast::NodeId, + data: DefPathData) + -> DefIndex { + assert!(!self.node_map.contains_key(&node_id), + "adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}", + node_id, + data, + self.data[self.node_map[&node_id].as_usize()]); + + // Find a unique DefKey. This basically means incrementing the disambiguator + // until we get no match. + let mut key = DefKey { + parent: parent, + disambiguated_data: DisambiguatedDefPathData { + data: data, + disambiguator: 0 + } + }; + + while self.key_map.contains_key(&key) { + key.disambiguated_data.disambiguator += 1; + } + + // Create the definition. + let index = DefIndex::new(self.data.len()); + self.data.push(DefData { key: key.clone(), node_id: node_id }); + self.node_map.insert(node_id, index); + self.key_map.insert(key, index); + + index + } +} + +impl DefPathData { + pub fn as_interned_str(&self) -> InternedString { + use self::DefPathData::*; + match *self { + Type(name) | + Mod(name) | + Value(name) | + MacroDef(name) | + TypeParam(name) | + LifetimeDef(name) | + EnumVariant(name) | + DetachedCrate(name) | + Binding(name) => { + name.as_str() + } + + Field(hir::StructFieldKind::NamedField(name, _)) => { + name.as_str() + } + + PositionalField | + Field(hir::StructFieldKind::UnnamedField(_)) => { + InternedString::new("") + } + + // note that this does not show up in user printouts + CrateRoot => { + InternedString::new("") + } + + // note that this does not show up in user printouts + InlinedRoot(_) => { + InternedString::new("") + } + + Misc => { + InternedString::new("?") + } + + Impl => { + InternedString::new("") + } + + ClosureExpr => { + InternedString::new("") + } + + StructCtor => { + InternedString::new("") + } + + Initializer => { + InternedString::new("") + } + } + } + + pub fn to_string(&self) -> String { + self.as_interned_str().to_string() + } +} + +pub fn make_def_path(start_index: DefIndex, mut get_key: FN) -> DefPath + where FN: FnMut(DefIndex) -> DefKey +{ + let mut result = vec![]; + let mut index = Some(start_index); + while let Some(p) = index { + let key = get_key(p); + match key.disambiguated_data.data { + DefPathData::CrateRoot => { + assert!(key.parent.is_none()); + break; + } + DefPathData::InlinedRoot(ref p) => { + assert!(key.parent.is_none()); + result.extend(p.iter().cloned().rev()); + break; + } + _ => { + result.push(key.disambiguated_data); + index = key.parent; + } + } + } + result.reverse(); + result +} diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index 0486fd3a0d1bb..aba6429abaefd 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -12,12 +12,11 @@ pub use self::Node::*; pub use self::PathElem::*; use self::MapEntry::*; use self::collector::NodeCollector; +pub use self::definitions::{Definitions, DefKey, DefPath, DefPathData, DisambiguatedDefPathData}; -use metadata::cstore::LOCAL_CRATE; use metadata::inline::InlinedItem; use metadata::inline::InlinedItem as II; use middle::def_id::DefId; -use util::nodemap::NodeSet; use syntax::abi; use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID}; @@ -39,6 +38,7 @@ use std::slice; pub mod blocks; mod collector; +pub mod definitions; #[derive(Clone, Copy, PartialEq, Debug)] pub enum PathElem { @@ -268,10 +268,28 @@ pub struct Map<'ast> { /// plain old integers. map: RefCell>>, - definitions_map: RefCell, + definitions: RefCell, } impl<'ast> Map<'ast> { + pub fn num_local_def_ids(&self) -> usize { + self.definitions.borrow().len() + } + + pub fn def_key(&self, def_id: DefId) -> DefKey { + assert!(def_id.is_local()); + self.definitions.borrow().def_key(def_id.index) + } + + pub fn def_path_from_id(&self, id: NodeId) -> DefPath { + self.def_path(self.local_def_id(id)) + } + + pub fn def_path(&self, def_id: DefId) -> DefPath { + assert!(def_id.is_local()); + self.definitions.borrow().def_path(def_id.index) + } + pub fn local_def_id(&self, node: NodeId) -> DefId { self.opt_local_def_id(node).unwrap_or_else(|| { panic!("local_def_id: no entry for `{}`, which has a map of `{:?}`", @@ -280,30 +298,27 @@ impl<'ast> Map<'ast> { } pub fn opt_local_def_id(&self, node: NodeId) -> Option { - if self.definitions_map.borrow().contains(&node) { - Some(DefId::xxx_local(node)) - } else { - None - } + self.definitions.borrow().opt_local_def_id(node) } pub fn as_local_node_id(&self, def_id: DefId) -> Option { - if def_id.krate == LOCAL_CRATE { - assert!(self.definitions_map.borrow().contains(&def_id.xxx_node)); - Some(def_id.xxx_node) - } else { - None - } + self.definitions.borrow().as_local_node_id(def_id) } /// for default methods, we create a fake node-id; this method /// adds that fake node-id to the def-id tables pub fn synthesize_default_method_def_id(&self, - _impl_def_id: DefId, - new_method_id: NodeId) + impl_def_id: DefId, + new_method_id: NodeId, + method_name: Name) -> DefId { - self.definitions_map.borrow_mut().insert(new_method_id); - DefId::xxx_local(new_method_id) + assert!(impl_def_id.is_local()); + let index = + self.definitions.borrow_mut() + .create_def_with_parent(Some(impl_def_id.index), + new_method_id, + DefPathData::Value(method_name)); + DefId::local(index) } fn entry_count(&self) -> usize { @@ -791,7 +806,7 @@ impl Folder for IdAndSpanUpdater { pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> { let mut collector = NodeCollector::root(); visit::walk_crate(&mut collector, &forest.krate); - let NodeCollector { map, definitions_map, .. } = collector; + let NodeCollector { map, definitions, .. } = collector; if log_enabled!(::log::DEBUG) { // This only makes sense for ordered stores; note the @@ -812,7 +827,7 @@ pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> { Map { forest: forest, map: RefCell::new(map), - definitions_map: RefCell::new(definitions_map), + definitions: RefCell::new(definitions), } } @@ -821,6 +836,7 @@ pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> { /// the item itself. pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>, path: Vec, + def_path: DefPath, ii: InlinedItem, fold_ops: F) -> &'ast InlinedItem { @@ -845,14 +861,16 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>, let ii_parent_id = fld.new_id(DUMMY_NODE_ID); let mut collector = - NodeCollector::extend(ii_parent, - ii_parent_id, - mem::replace(&mut *map.map.borrow_mut(), vec![]), - mem::replace(&mut *map.definitions_map.borrow_mut(), NodeSet())); + NodeCollector::extend( + ii_parent, + ii_parent_id, + def_path, + mem::replace(&mut *map.map.borrow_mut(), vec![]), + mem::replace(&mut *map.definitions.borrow_mut(), Definitions::new())); ii_parent.ii.visit(&mut collector); *map.map.borrow_mut() = collector.map; - *map.definitions_map.borrow_mut() = collector.definitions_map; + *map.definitions.borrow_mut() = collector.definitions; &ii_parent.ii } diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs index a6cbb4ec50490..7b8ad78da74dc 100644 --- a/src/librustc/metadata/common.rs +++ b/src/librustc/metadata/common.rs @@ -43,9 +43,15 @@ pub const tag_items_data_parent_item: usize = 0x28; pub const tag_items_data_item_is_tuple_struct_ctor: usize = 0x29; -pub const tag_index: usize = 0x2a; +pub const tag_items_closure_kind: usize = 0x2a; -// GAP 0x2b, 0x2c, 0x2d, 0x2e +pub const tag_items_closure_ty: usize = 0x2b; + +pub const tag_index: usize = 0x2c; + +pub const tag_def_key: usize = 0x2d; + +// GAP 0x2e pub const tag_meta_item_name_value: usize = 0x2f; @@ -137,8 +143,7 @@ enum_from_u32! { tag_table_adjustments = 0x61, tag_table_moves_map = 0x62, tag_table_capture_map = 0x63, - tag_table_closure_tys = 0x64, - tag_table_closure_kinds = 0x65, + // GAP 0x64, 0x65 tag_table_upvar_capture_map = 0x66, tag_table_capture_modes = 0x67, // GAP 0x68 @@ -162,12 +167,12 @@ pub const tag_dylib_dependency_formats: usize = 0x106; // top-level only // tag_lang_items // - tag_lang_items_item // - tag_lang_items_item_id: u32 -// - tag_lang_items_item_node_id: u32 +// - tag_lang_items_item_index: u32 pub const tag_lang_items: usize = 0x107; // top-level only pub const tag_lang_items_item: usize = 0x73; pub const tag_lang_items_item_id: usize = 0x74; -pub const tag_lang_items_item_node_id: usize = 0x75; +pub const tag_lang_items_item_index: usize = 0x75; pub const tag_lang_items_missing: usize = 0x76; pub const tag_item_unnamed_field: usize = 0x77; @@ -215,7 +220,7 @@ pub struct LinkMeta { pub const tag_struct_fields: usize = 0x10d; // top-level only pub const tag_struct_field: usize = 0x8a; -pub const tag_struct_field_id: usize = 0x8b; +// GAP 0x8b pub const tag_attribute_is_sugared_doc: usize = 0x8c; diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 04f164c296d2e..fe4a909a08516 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -325,6 +325,7 @@ impl<'a> CrateReader<'a> { let cmeta = Rc::new(cstore::crate_metadata { name: name.to_string(), local_path: RefCell::new(SmallVector::zero()), + local_def_path: RefCell::new(vec![]), index: decoder::load_index(metadata.as_slice()), data: metadata, cnum_map: RefCell::new(cnum_map), @@ -548,7 +549,8 @@ impl<'a> CrateReader<'a> { self.sess.abort_if_errors(); } - let registrar = decoder::get_plugin_registrar_fn(ekrate.metadata.as_slice()) + let registrar = + decoder::get_plugin_registrar_fn(ekrate.metadata.as_slice()) .map(|id| decoder::get_symbol_from_buf(ekrate.metadata.as_slice(), id)); match (ekrate.dylib.as_ref(), registrar) { @@ -751,6 +753,9 @@ impl<'a, 'b> LocalCrateReader<'a, 'b> { i.span, PathKind::Crate, true); + let def_id = self.ast_map.local_def_id(i.id); + let def_path = self.ast_map.def_path(def_id); + cmeta.update_local_def_path(def_path); self.ast_map.with_path(i.id, |path| { cmeta.update_local_path(path) }); diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 70a969e4d8221..402aa52612e87 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -14,7 +14,7 @@ use front::map as ast_map; use metadata::cstore; use metadata::decoder; use metadata::inline::InlinedItem; -use middle::def_id::DefId; +use middle::def_id::{DefId, DefIndex}; use middle::lang_items; use middle::ty; use util::nodemap::FnvHashMap; @@ -33,7 +33,7 @@ pub struct MethodInfo { pub fn get_symbol(cstore: &cstore::CStore, def: DefId) -> String { let cdata = cstore.get_crate_data(def.krate); - decoder::get_symbol(&cdata, def.xxx_node) + decoder::get_symbol(&cdata, def.index) } /// Iterates over all the language items in the given crate. @@ -41,7 +41,7 @@ pub fn each_lang_item(cstore: &cstore::CStore, cnum: ast::CrateNum, f: F) -> bool where - F: FnMut(ast::NodeId, usize) -> bool, + F: FnMut(DefIndex, usize) -> bool, { let crate_data = cstore.get_crate_data(cnum); decoder::each_lang_item(&*crate_data, f) @@ -59,7 +59,7 @@ pub fn each_child_of_item(cstore: &cstore::CStore, }; decoder::each_child_of_item(cstore.intr.clone(), &*crate_data, - def_id.xxx_node, + def_id.index, get_crate_data, callback) } @@ -83,7 +83,7 @@ pub fn each_top_level_item_of_crate(cstore: &cstore::CStore, pub fn get_item_path(tcx: &ty::ctxt, def: DefId) -> Vec { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - let path = decoder::get_item_path(&*cdata, def.xxx_node); + let path = decoder::get_item_path(&*cdata, def.index); cdata.with_local_path(|cpath| { let mut r = Vec::with_capacity(cpath.len() + path.len()); @@ -96,7 +96,7 @@ pub fn get_item_path(tcx: &ty::ctxt, def: DefId) -> Vec { pub fn get_item_name(tcx: &ty::ctxt, def: DefId) -> ast::Name { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_item_name(&cstore.intr, &cdata, def.xxx_node) + decoder::get_item_name(&cstore.intr, &cdata, def.index) } pub enum FoundAst<'ast> { @@ -113,14 +113,14 @@ pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId, -> FoundAst<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::maybe_get_item_ast(&*cdata, tcx, def.xxx_node, decode_inlined_item) + decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item) } /// Returns information about the given implementation. pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: DefId) -> Vec { let cdata = cstore.get_crate_data(impl_def_id.krate); - decoder::get_impl_items(&*cdata, impl_def_id.xxx_node) + decoder::get_impl_items(&*cdata, impl_def_id.index) } pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) @@ -128,7 +128,7 @@ pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) let cdata = tcx.sess.cstore.get_crate_data(def.krate); decoder::get_impl_or_trait_item(tcx.sess.cstore.intr.clone(), &*cdata, - def.xxx_node, + def.index, tcx) } @@ -136,24 +136,24 @@ pub fn get_trait_name(cstore: &cstore::CStore, def: DefId) -> ast::Name { let cdata = cstore.get_crate_data(def.krate); decoder::get_trait_name(cstore.intr.clone(), &*cdata, - def.xxx_node) + def.index) } pub fn is_static_method(cstore: &cstore::CStore, def: DefId) -> bool { let cdata = cstore.get_crate_data(def.krate); - decoder::is_static_method(&*cdata, def.xxx_node) + decoder::is_static_method(&*cdata, def.index) } pub fn get_trait_item_def_ids(cstore: &cstore::CStore, def: DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_trait_item_def_ids(&*cdata, def.xxx_node) + decoder::get_trait_item_def_ids(&*cdata, def.index) } pub fn get_item_variances(cstore: &cstore::CStore, def: DefId) -> ty::ItemVariances { let cdata = cstore.get_crate_data(def.krate); - decoder::get_item_variances(&*cdata, def.xxx_node) + decoder::get_item_variances(&*cdata, def.index) } pub fn get_provided_trait_methods<'tcx>(tcx: &ty::ctxt<'tcx>, @@ -161,43 +161,43 @@ pub fn get_provided_trait_methods<'tcx>(tcx: &ty::ctxt<'tcx>, -> Vec>> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.xxx_node, tcx) + decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.index, tcx) } pub fn get_associated_consts<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> Vec>> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_associated_consts(cstore.intr.clone(), &*cdata, def.xxx_node, tcx) + decoder::get_associated_consts(cstore.intr.clone(), &*cdata, def.index, tcx) } pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: DefId) -> Option { let cdata = cstore.get_crate_data(def.krate); - decoder::get_type_name_if_impl(&*cdata, def.xxx_node) + decoder::get_type_name_if_impl(&*cdata, def.index) } pub fn get_methods_if_impl(cstore: &cstore::CStore, def: DefId) -> Option > { let cdata = cstore.get_crate_data(def.krate); - decoder::get_methods_if_impl(cstore.intr.clone(), &*cdata, def.xxx_node) + decoder::get_methods_if_impl(cstore.intr.clone(), &*cdata, def.index) } pub fn get_item_attrs(cstore: &cstore::CStore, def_id: DefId) -> Vec { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_item_attrs(&*cdata, def_id.xxx_node) + decoder::get_item_attrs(&*cdata, def_id.index) } pub fn get_struct_field_names(cstore: &cstore::CStore, def: DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_struct_field_names(&cstore.intr, &*cdata, def.xxx_node) + decoder::get_struct_field_names(&cstore.intr, &*cdata, def.index) } -pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: DefId) -> FnvHashMap> { +pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: DefId) + -> FnvHashMap> { let cdata = cstore.get_crate_data(def.krate); decoder::get_struct_field_attrs(&*cdata) } @@ -207,19 +207,19 @@ pub fn get_type<'tcx>(tcx: &ty::ctxt<'tcx>, -> ty::TypeScheme<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_type(&*cdata, def.xxx_node, tcx) + decoder::get_type(&*cdata, def.index, tcx) } pub fn get_trait_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_trait_def(&*cdata, def.xxx_node, tcx) + decoder::get_trait_def(&*cdata, def.index, tcx) } pub fn get_adt_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_adt_def(&cstore.intr, &*cdata, def.xxx_node, tcx) + decoder::get_adt_def(&cstore.intr, &*cdata, def.index, tcx) } pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) @@ -227,7 +227,7 @@ pub fn get_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_predicates(&*cdata, def.xxx_node, tcx) + decoder::get_predicates(&*cdata, def.index, tcx) } pub fn get_super_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) @@ -235,7 +235,7 @@ pub fn get_super_predicates<'tcx>(tcx: &ty::ctxt<'tcx>, def: DefId) { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_super_predicates(&*cdata, def.xxx_node, tcx) + decoder::get_super_predicates(&*cdata, def.index, tcx) } pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>, @@ -244,7 +244,7 @@ pub fn get_impl_polarity<'tcx>(tcx: &ty::ctxt<'tcx>, { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_polarity(&*cdata, def.xxx_node) + decoder::get_impl_polarity(&*cdata, def.index) } pub fn get_custom_coerce_unsized_kind<'tcx>( @@ -254,7 +254,7 @@ pub fn get_custom_coerce_unsized_kind<'tcx>( { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_custom_coerce_unsized_kind(&*cdata, def.xxx_node) + decoder::get_custom_coerce_unsized_kind(&*cdata, def.index) } // Given a def_id for an impl, return the trait it implements, @@ -264,7 +264,7 @@ pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>, -> Option> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_trait(&*cdata, def.xxx_node, tcx) + decoder::get_impl_trait(&*cdata, def.index, tcx) } pub fn get_native_libraries(cstore: &cstore::CStore, crate_num: ast::CrateNum) @@ -279,7 +279,7 @@ pub fn each_inherent_implementation_for_type(cstore: &cstore::CStore, F: FnMut(DefId), { let cdata = cstore.get_crate_data(def_id.krate); - decoder::each_inherent_implementation_for_type(&*cdata, def_id.xxx_node, callback) + decoder::each_inherent_implementation_for_type(&*cdata, def_id.index, callback) } pub fn each_implementation_for_trait(cstore: &cstore::CStore, @@ -300,7 +300,7 @@ pub fn get_trait_of_item(cstore: &cstore::CStore, tcx: &ty::ctxt) -> Option { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_trait_of_item(&*cdata, def_id.xxx_node, tcx) + decoder::get_trait_of_item(&*cdata, def_id.index, tcx) } pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, @@ -308,7 +308,7 @@ pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, -> Option { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.xxx_node) + decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.index) } pub fn get_dylib_dependency_formats(cstore: &cstore::CStore, @@ -330,7 +330,7 @@ pub fn get_method_arg_names(cstore: &cstore::CStore, did: DefId) -> Vec { let cdata = cstore.get_crate_data(did.krate); - decoder::get_method_arg_names(&*cdata, did.xxx_node) + decoder::get_method_arg_names(&*cdata, did.index) } pub fn get_reachable_ids(cstore: &cstore::CStore, cnum: ast::CrateNum) @@ -342,24 +342,24 @@ pub fn get_reachable_ids(cstore: &cstore::CStore, cnum: ast::CrateNum) pub fn is_typedef(cstore: &cstore::CStore, did: DefId) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_typedef(&*cdata, did.xxx_node) + decoder::is_typedef(&*cdata, did.index) } pub fn is_const_fn(cstore: &cstore::CStore, did: DefId) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_const_fn(&*cdata, did.xxx_node) + decoder::is_const_fn(&*cdata, did.index) } pub fn is_impl(cstore: &cstore::CStore, did: DefId) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_impl(&*cdata, did.xxx_node) + decoder::is_impl(&*cdata, did.index) } pub fn get_stability(cstore: &cstore::CStore, def: DefId) -> Option { let cdata = cstore.get_crate_data(def.krate); - decoder::get_stability(&*cdata, def.xxx_node) + decoder::get_stability(&*cdata, def.index) } pub fn is_staged_api(cstore: &cstore::CStore, krate: ast::CrateNum) -> bool { @@ -369,21 +369,42 @@ pub fn is_staged_api(cstore: &cstore::CStore, krate: ast::CrateNum) -> bool { pub fn get_repr_attrs(cstore: &cstore::CStore, def: DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_repr_attrs(&*cdata, def.xxx_node) + decoder::get_repr_attrs(&*cdata, def.index) } pub fn is_defaulted_trait(cstore: &cstore::CStore, trait_def_id: DefId) -> bool { let cdata = cstore.get_crate_data(trait_def_id.krate); - decoder::is_defaulted_trait(&*cdata, trait_def_id.xxx_node) + decoder::is_defaulted_trait(&*cdata, trait_def_id.index) } pub fn is_default_impl(cstore: &cstore::CStore, impl_did: DefId) -> bool { let cdata = cstore.get_crate_data(impl_did.krate); - decoder::is_default_impl(&*cdata, impl_did.xxx_node) + decoder::is_default_impl(&*cdata, impl_did.index) } pub fn is_extern_fn(cstore: &cstore::CStore, did: DefId, tcx: &ty::ctxt) -> bool { let cdata = cstore.get_crate_data(did.krate); - decoder::is_extern_fn(&*cdata, did.xxx_node, tcx) + decoder::is_extern_fn(&*cdata, did.index, tcx) } + +pub fn closure_kind<'tcx>(tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureKind { + assert!(!def_id.is_local()); + let cdata = tcx.sess.cstore.get_crate_data(def_id.krate); + decoder::closure_kind(&*cdata, def_id.index) +} + +pub fn closure_ty<'tcx>(tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureTy<'tcx> { + assert!(!def_id.is_local()); + let cdata = tcx.sess.cstore.get_crate_data(def_id.krate); + decoder::closure_ty(&*cdata, def_id.index, tcx) +} + +pub fn def_path(tcx: &ty::ctxt, def: DefId) -> ast_map::DefPath { + let cstore = &tcx.sess.cstore; + let cdata = cstore.get_crate_data(def.krate); + let path = decoder::def_path(&*cdata, def.index); + let local_path = cdata.local_def_path(); + local_path.into_iter().chain(path).collect() +} + diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 915027041bc44..48676a2a1b48a 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -59,6 +59,7 @@ pub struct ImportedFileMap { pub struct crate_metadata { pub name: String, pub local_path: RefCell>, + pub local_def_path: RefCell, pub data: MetadataBlob, pub cnum_map: RefCell, pub cnum: ast::CrateNum, @@ -312,6 +313,23 @@ impl crate_metadata { } } + pub fn local_def_path(&self) -> ast_map::DefPath { + let local_def_path = self.local_def_path.borrow(); + if local_def_path.is_empty() { + let name = ast_map::DefPathData::DetachedCrate(token::intern(&self.name)); + vec![ast_map::DisambiguatedDefPathData { data: name, disambiguator: 0 }] + } else { + local_def_path.clone() + } + } + + pub fn update_local_def_path(&self, candidate: ast_map::DefPath) { + let mut local_def_path = self.local_def_path.borrow_mut(); + if local_def_path.is_empty() || candidate.len() < local_def_path.len() { + *local_def_path = candidate; + } + } + pub fn is_allocator(&self) -> bool { let attrs = decoder::get_crate_attributes(self.data()); attr::contains_name(&attrs, "allocator") diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 8ce31e533de82..58e87f1910a68 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -30,7 +30,7 @@ use metadata::index; use metadata::inline::InlinedItem; use metadata::tydecode::TyDecoder; use middle::def; -use middle::def_id::DefId; +use middle::def_id::{DefId, DefIndex}; use middle::lang_items; use middle::subst; use middle::ty::{ImplContainer, TraitContainer}; @@ -59,15 +59,15 @@ use syntax::ptr::P; pub type Cmd<'a> = &'a crate_metadata; impl crate_metadata { - fn get_item(&self, item_id: ast::NodeId) -> Option { + fn get_item(&self, item_id: DefIndex) -> Option { self.index.lookup_item(self.data(), item_id).map(|pos| { reader::doc_at(self.data(), pos as usize).unwrap().doc }) } - fn lookup_item(&self, item_id: ast::NodeId) -> rbml::Doc { + fn lookup_item(&self, item_id: DefIndex) -> rbml::Doc { match self.get_item(item_id) { - None => panic!("lookup_item: id not found: {}", item_id), + None => panic!("lookup_item: id not found: {:?}", item_id), Some(d) => d } } @@ -75,7 +75,7 @@ impl crate_metadata { pub fn load_index(data: &[u8]) -> index::Index { let index = reader::get_doc(rbml::Doc::new(data), tag_index); - index::Index::from_buf(index.data, index.start, index.end) + index::Index::from_rbml(index) } pub fn crate_rustc_version(data: &[u8]) -> Option { @@ -170,7 +170,8 @@ fn item_symbol(item: rbml::Doc) -> String { fn translated_def_id(cdata: Cmd, d: rbml::Doc) -> DefId { let id = reader::doc_as_u64(d); - let def_id = DefId { krate: (id >> 32) as u32, xxx_node: id as u32 }; + let index = DefIndex::new((id & 0xFFFF_FFFF) as usize); + let def_id = DefId { krate: (id >> 32) as u32, index: index }; translate_def_id(cdata, def_id) } @@ -203,14 +204,14 @@ fn variant_disr_val(d: rbml::Doc) -> Option { fn doc_type<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) -> Ty<'tcx> { let tp = reader::get_doc(doc, tag_items_data_item_type); TyDecoder::with_doc(tcx, cdata.cnum, tp, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_ty() } fn maybe_doc_type<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) -> Option> { reader::maybe_get_doc(doc, tag_items_data_item_type).map(|tp| { TyDecoder::with_doc(tcx, cdata.cnum, tp, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_ty() }) } @@ -219,7 +220,7 @@ fn doc_method_fty<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) -> ty::BareFnTy<'tcx> { let tp = reader::get_doc(doc, tag_item_method_fty); TyDecoder::with_doc(tcx, cdata.cnum, tp, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_bare_fn_ty() } @@ -231,7 +232,7 @@ pub fn item_type<'tcx>(_item_id: DefId, item: rbml::Doc, fn doc_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) -> ty::TraitRef<'tcx> { TyDecoder::with_doc(tcx, cdata.cnum, doc, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_trait_ref() } @@ -345,7 +346,7 @@ fn parse_associated_type_names(item_doc: rbml::Doc) -> Vec { } pub fn get_trait_def<'tcx>(cdata: Cmd, - item_id: ast::NodeId, + item_id: DefIndex, tcx: &ty::ctxt<'tcx>) -> ty::TraitDef<'tcx> { let item_doc = cdata.lookup_item(item_id); @@ -368,7 +369,7 @@ pub fn get_trait_def<'tcx>(cdata: Cmd, pub fn get_adt_def<'tcx>(intr: &IdentInterner, cdata: Cmd, - item_id: ast::NodeId, + item_id: DefIndex, tcx: &ty::ctxt<'tcx>) -> ty::AdtDefMaster<'tcx> { fn get_enum_variants<'tcx>(intr: &IdentInterner, @@ -378,7 +379,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, let mut disr_val = 0; reader::tagged_docs(doc, tag_items_data_item_variant).map(|p| { let did = translated_def_id(cdata, p); - let item = cdata.lookup_item(did.xxx_node); + let item = cdata.lookup_item(did.index); if let Some(disr) = variant_disr_val(item) { disr_val = disr; @@ -428,7 +429,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, } let doc = cdata.lookup_item(item_id); - let did = DefId { krate: cdata.cnum, xxx_node: item_id }; + let did = DefId { krate: cdata.cnum, index: item_id }; let (kind, variants) = match item_family(doc) { Enum => (ty::AdtKind::Enum, get_enum_variants(intr, cdata, doc, tcx)), @@ -448,7 +449,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, // from the ctor. debug!("evaluating the ctor-type of {:?}", variant.name); - let ctor_ty = get_type(cdata, variant.did.xxx_node, tcx).ty; + let ctor_ty = get_type(cdata, variant.did.index, tcx).ty; debug!("evaluating the ctor-type of {:?}.. {:?}", variant.name, ctor_ty); @@ -468,7 +469,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, } else { for field in &variant.fields { debug!("evaluating the type of {:?}::{:?}", variant.name, field.name); - let ty = get_type(cdata, field.did.xxx_node, tcx).ty; + let ty = get_type(cdata, field.did.index, tcx).ty; field.fulfill_ty(ty); debug!("evaluating the type of {:?}::{:?}: {:?}", variant.name, field.name, ty); @@ -480,7 +481,7 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner, } pub fn get_predicates<'tcx>(cdata: Cmd, - item_id: ast::NodeId, + item_id: DefIndex, tcx: &ty::ctxt<'tcx>) -> ty::GenericPredicates<'tcx> { @@ -489,7 +490,7 @@ pub fn get_predicates<'tcx>(cdata: Cmd, } pub fn get_super_predicates<'tcx>(cdata: Cmd, - item_id: ast::NodeId, + item_id: DefIndex, tcx: &ty::ctxt<'tcx>) -> ty::GenericPredicates<'tcx> { @@ -497,11 +498,11 @@ pub fn get_super_predicates<'tcx>(cdata: Cmd, doc_predicates(item_doc, tcx, cdata, tag_item_super_predicates) } -pub fn get_type<'tcx>(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt<'tcx>) +pub fn get_type<'tcx>(cdata: Cmd, id: DefIndex, tcx: &ty::ctxt<'tcx>) -> ty::TypeScheme<'tcx> { let item_doc = cdata.lookup_item(id); - let t = item_type(DefId { krate: cdata.cnum, xxx_node: id }, item_doc, tcx, + let t = item_type(DefId { krate: cdata.cnum, index: id }, item_doc, tcx, cdata); let generics = doc_generics(item_doc, tcx, cdata, tag_item_generics); ty::TypeScheme { @@ -510,7 +511,7 @@ pub fn get_type<'tcx>(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt<'tcx>) } } -pub fn get_stability(cdata: Cmd, id: ast::NodeId) -> Option { +pub fn get_stability(cdata: Cmd, id: DefIndex) -> Option { let item = cdata.lookup_item(id); reader::maybe_get_doc(item, tag_items_data_item_stability).map(|doc| { let mut decoder = reader::Decoder::new(doc); @@ -518,7 +519,7 @@ pub fn get_stability(cdata: Cmd, id: ast::NodeId) -> Option { }) } -pub fn get_repr_attrs(cdata: Cmd, id: ast::NodeId) -> Vec { +pub fn get_repr_attrs(cdata: Cmd, id: DefIndex) -> Vec { let item = cdata.lookup_item(id); match reader::maybe_get_doc(item, tag_items_data_item_repr).map(|doc| { let mut decoder = reader::Decoder::new(doc); @@ -530,7 +531,7 @@ pub fn get_repr_attrs(cdata: Cmd, id: ast::NodeId) -> Vec { } pub fn get_impl_polarity<'tcx>(cdata: Cmd, - id: ast::NodeId) + id: DefIndex) -> Option { let item_doc = cdata.lookup_item(id); @@ -545,7 +546,7 @@ pub fn get_impl_polarity<'tcx>(cdata: Cmd, pub fn get_custom_coerce_unsized_kind<'tcx>( cdata: Cmd, - id: ast::NodeId) + id: DefIndex) -> Option { let item_doc = cdata.lookup_item(id); @@ -556,7 +557,7 @@ pub fn get_custom_coerce_unsized_kind<'tcx>( } pub fn get_impl_trait<'tcx>(cdata: Cmd, - id: ast::NodeId, + id: DefIndex, tcx: &ty::ctxt<'tcx>) -> Option> { @@ -572,12 +573,12 @@ pub fn get_impl_trait<'tcx>(cdata: Cmd, } } -pub fn get_symbol(cdata: Cmd, id: ast::NodeId) -> String { +pub fn get_symbol(cdata: Cmd, id: DefIndex) -> String { return item_symbol(cdata.lookup_item(id)); } /// If you have a crate_metadata, call get_symbol instead -pub fn get_symbol_from_buf(data: &[u8], id: ast::NodeId) -> String { +pub fn get_symbol_from_buf(data: &[u8], id: DefIndex) -> String { let index = load_index(data); let pos = index.lookup_item(data, id).unwrap(); let doc = reader::doc_at(data, pos as usize).unwrap().doc; @@ -594,18 +595,17 @@ pub enum DefLike { /// Iterates over the language items in the given crate. pub fn each_lang_item(cdata: Cmd, mut f: F) -> bool where - F: FnMut(ast::NodeId, usize) -> bool, + F: FnMut(DefIndex, usize) -> bool, { let root = rbml::Doc::new(cdata.data()); let lang_items = reader::get_doc(root, tag_lang_items); reader::tagged_docs(lang_items, tag_lang_items_item).all(|item_doc| { let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id); let id = reader::doc_as_u32(id_doc) as usize; - let node_id_doc = reader::get_doc(item_doc, - tag_lang_items_item_node_id); - let node_id = reader::doc_as_u32(node_id_doc) as ast::NodeId; + let index_doc = reader::get_doc(item_doc, tag_lang_items_item_index); + let index = DefIndex::from_u32(reader::doc_as_u32(index_doc)); - f(node_id, id) + f(index, id) }) } @@ -634,7 +634,7 @@ fn each_child_of_item_or_crate(intr: Rc, }; // Get the item. - match crate_data.get_item(child_def_id.xxx_node) { + match crate_data.get_item(child_def_id.index) { None => {} Some(child_item_doc) => { // Hand off the item to the callback. @@ -652,12 +652,12 @@ fn each_child_of_item_or_crate(intr: Rc, for inherent_impl_def_id_doc in reader::tagged_docs(item_doc, tag_items_data_item_inherent_impl) { let inherent_impl_def_id = item_def_id(inherent_impl_def_id_doc, cdata); - if let Some(inherent_impl_doc) = cdata.get_item(inherent_impl_def_id.xxx_node) { + if let Some(inherent_impl_doc) = cdata.get_item(inherent_impl_def_id.index) { for impl_item_def_id_doc in reader::tagged_docs(inherent_impl_doc, tag_item_impl_item) { let impl_item_def_id = item_def_id(impl_item_def_id_doc, cdata); - if let Some(impl_method_doc) = cdata.get_item(impl_item_def_id.xxx_node) { + if let Some(impl_method_doc) = cdata.get_item(impl_item_def_id.index) { if let StaticMethod = item_family(impl_method_doc) { // Hand off the static method to the callback. let static_method_name = item_name(&*intr, impl_method_doc); @@ -693,7 +693,7 @@ fn each_child_of_item_or_crate(intr: Rc, }; // Get the item. - if let Some(child_item_doc) = crate_data.get_item(child_def_id.xxx_node) { + if let Some(child_item_doc) = crate_data.get_item(child_def_id.index) { // Hand off the item to the callback. let def_like = item_to_def_like(crate_data, child_item_doc, child_def_id); // These items have a public visibility because they're part of @@ -706,7 +706,7 @@ fn each_child_of_item_or_crate(intr: Rc, /// Iterates over each child of the given item. pub fn each_child_of_item(intr: Rc, cdata: Cmd, - id: ast::NodeId, + id: DefIndex, get_crate_data: G, callback: F) where F: FnMut(DefLike, ast::Name, hir::Visibility), @@ -745,11 +745,11 @@ pub fn each_top_level_item_of_crate(intr: Rc, callback) } -pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec { +pub fn get_item_path(cdata: Cmd, id: DefIndex) -> Vec { item_path(cdata.lookup_item(id)) } -pub fn get_item_name(intr: &IdentInterner, cdata: Cmd, id: ast::NodeId) -> ast::Name { +pub fn get_item_name(intr: &IdentInterner, cdata: Cmd, id: DefIndex) -> ast::Name { item_name(intr, cdata.lookup_item(id)) } @@ -757,22 +757,25 @@ pub type DecodeInlinedItem<'a> = Box FnMut(Cmd, &ty::ctxt<'tcx>, Vec, + hir_map::DefPath, rbml::Doc) - -> Result<&'tcx InlinedItem, Vec> + 'a>; + -> Result<&'tcx InlinedItem, (Vec, + hir_map::DefPath)> + 'a>; -pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: ast::NodeId, +pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: DefIndex, mut decode_inlined_item: DecodeInlinedItem) -> csearch::FoundAst<'tcx> { - debug!("Looking up item: {}", id); + debug!("Looking up item: {:?}", id); let item_doc = cdata.lookup_item(id); let path = item_path(item_doc).split_last().unwrap().1.to_vec(); - match decode_inlined_item(cdata, tcx, path, item_doc) { + let def_path = def_path(cdata, id); + match decode_inlined_item(cdata, tcx, path, def_path, item_doc) { Ok(ii) => csearch::FoundAst::Found(ii), - Err(path) => { + Err((path, def_path)) => { match item_parent_item(cdata, item_doc) { Some(did) => { - let parent_item = cdata.lookup_item(did.xxx_node); - match decode_inlined_item(cdata, tcx, path, parent_item) { + let parent_item = cdata.lookup_item(did.index); + match decode_inlined_item(cdata, tcx, path, def_path, parent_item) { Ok(ii) => csearch::FoundAst::FoundParent(did, ii), Err(_) => csearch::FoundAst::NotFound } @@ -811,7 +814,7 @@ fn get_explicit_self(item: rbml::Doc) -> ty::ExplicitSelfCategory { } /// Returns the def IDs of all the items in the given implementation. -pub fn get_impl_items(cdata: Cmd, impl_id: ast::NodeId) +pub fn get_impl_items(cdata: Cmd, impl_id: DefIndex) -> Vec { reader::tagged_docs(cdata.lookup_item(impl_id), tag_item_impl_item).map(|doc| { let def_id = item_def_id(doc, cdata); @@ -826,13 +829,13 @@ pub fn get_impl_items(cdata: Cmd, impl_id: ast::NodeId) pub fn get_trait_name(intr: Rc, cdata: Cmd, - id: ast::NodeId) + id: DefIndex) -> ast::Name { let doc = cdata.lookup_item(id); item_name(&*intr, doc) } -pub fn is_static_method(cdata: Cmd, id: ast::NodeId) -> bool { +pub fn is_static_method(cdata: Cmd, id: DefIndex) -> bool { let doc = cdata.lookup_item(id); match item_sort(doc) { Some('r') | Some('p') => { @@ -844,7 +847,7 @@ pub fn is_static_method(cdata: Cmd, id: ast::NodeId) -> bool { pub fn get_impl_or_trait_item<'tcx>(intr: Rc, cdata: Cmd, - id: ast::NodeId, + id: DefIndex, tcx: &ty::ctxt<'tcx>) -> ty::ImplOrTraitItem<'tcx> { let item_doc = cdata.lookup_item(id); @@ -852,7 +855,7 @@ pub fn get_impl_or_trait_item<'tcx>(intr: Rc, let def_id = item_def_id(item_doc, cdata); let container_id = item_require_parent_item(cdata, item_doc); - let container_doc = cdata.lookup_item(container_id.xxx_node); + let container_doc = cdata.lookup_item(container_id.index); let container = match item_family(container_doc) { Trait => TraitContainer(container_id), _ => ImplContainer(container_id), @@ -902,7 +905,7 @@ pub fn get_impl_or_trait_item<'tcx>(intr: Rc, } } -pub fn get_trait_item_def_ids(cdata: Cmd, id: ast::NodeId) +pub fn get_trait_item_def_ids(cdata: Cmd, id: DefIndex) -> Vec { let item = cdata.lookup_item(id); reader::tagged_docs(item, tag_item_trait_item).map(|mth| { @@ -916,7 +919,7 @@ pub fn get_trait_item_def_ids(cdata: Cmd, id: ast::NodeId) }).collect() } -pub fn get_item_variances(cdata: Cmd, id: ast::NodeId) -> ty::ItemVariances { +pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> ty::ItemVariances { let item_doc = cdata.lookup_item(id); let variance_doc = reader::get_doc(item_doc, tag_item_variances); let mut decoder = reader::Decoder::new(variance_doc); @@ -925,19 +928,19 @@ pub fn get_item_variances(cdata: Cmd, id: ast::NodeId) -> ty::ItemVariances { pub fn get_provided_trait_methods<'tcx>(intr: Rc, cdata: Cmd, - id: ast::NodeId, + id: DefIndex, tcx: &ty::ctxt<'tcx>) -> Vec>> { let item = cdata.lookup_item(id); reader::tagged_docs(item, tag_item_trait_item).filter_map(|mth_id| { let did = item_def_id(mth_id, cdata); - let mth = cdata.lookup_item(did.xxx_node); + let mth = cdata.lookup_item(did.index); if item_sort(mth) == Some('p') { let trait_item = get_impl_or_trait_item(intr.clone(), cdata, - did.xxx_node, + did.index, tcx); if let ty::MethodTraitItem(ref method) = trait_item { Some((*method).clone()) @@ -952,7 +955,7 @@ pub fn get_provided_trait_methods<'tcx>(intr: Rc, pub fn get_associated_consts<'tcx>(intr: Rc, cdata: Cmd, - id: ast::NodeId, + id: DefIndex, tcx: &ty::ctxt<'tcx>) -> Vec>> { let item = cdata.lookup_item(id); @@ -960,13 +963,13 @@ pub fn get_associated_consts<'tcx>(intr: Rc, [tag_item_trait_item, tag_item_impl_item].iter().flat_map(|&tag| { reader::tagged_docs(item, tag).filter_map(|ac_id| { let did = item_def_id(ac_id, cdata); - let ac_doc = cdata.lookup_item(did.xxx_node); + let ac_doc = cdata.lookup_item(did.index); match item_sort(ac_doc) { Some('C') | Some('c') => { let trait_item = get_impl_or_trait_item(intr.clone(), cdata, - did.xxx_node, + did.index, tcx); if let ty::ConstTraitItem(ref ac) = trait_item { Some((*ac).clone()) @@ -981,7 +984,7 @@ pub fn get_associated_consts<'tcx>(intr: Rc, } pub fn get_type_name_if_impl(cdata: Cmd, - node_id: ast::NodeId) -> Option { + node_id: DefIndex) -> Option { let item = cdata.lookup_item(node_id); if item_family(item) != Impl { return None; @@ -994,7 +997,7 @@ pub fn get_type_name_if_impl(cdata: Cmd, pub fn get_methods_if_impl(intr: Rc, cdata: Cmd, - node_id: ast::NodeId) + node_id: DefIndex) -> Option > { let item = cdata.lookup_item(node_id); if item_family(item) != Impl { @@ -1011,7 +1014,7 @@ pub fn get_methods_if_impl(intr: Rc, let mut impl_methods = Vec::new(); for impl_method_id in impl_method_ids { - let impl_method_doc = cdata.lookup_item(impl_method_id.xxx_node); + let impl_method_doc = cdata.lookup_item(impl_method_id.index); let family = item_family(impl_method_doc); match family { StaticMethod | Method => { @@ -1031,7 +1034,7 @@ pub fn get_methods_if_impl(intr: Rc, /// If node_id is the constructor of a tuple struct, retrieve the NodeId of /// the actual type definition, otherwise, return None pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd, - node_id: ast::NodeId) + node_id: DefIndex) -> Option { let item = cdata.lookup_item(node_id); @@ -1041,24 +1044,24 @@ pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd, } pub fn get_item_attrs(cdata: Cmd, - orig_node_id: ast::NodeId) + orig_node_id: DefIndex) -> Vec { // The attributes for a tuple struct are attached to the definition, not the ctor; // we assume that someone passing in a tuple struct ctor is actually wanting to // look at the definition let node_id = get_tuple_struct_definition_if_ctor(cdata, orig_node_id); - let node_id = node_id.map(|x| x.xxx_node).unwrap_or(orig_node_id); + let node_id = node_id.map(|x| x.index).unwrap_or(orig_node_id); let item = cdata.lookup_item(node_id); get_attributes(item) } -pub fn get_struct_field_attrs(cdata: Cmd) -> FnvHashMap> { +pub fn get_struct_field_attrs(cdata: Cmd) -> FnvHashMap> { let data = rbml::Doc::new(cdata.data()); let fields = reader::get_doc(data, tag_struct_fields); reader::tagged_docs(fields, tag_struct_field).map(|field| { - let id = reader::doc_as_u32(reader::get_doc(field, tag_struct_field_id)); + let def_id = translated_def_id(cdata, reader::get_doc(field, tag_def_id)); let attrs = get_attributes(field); - (id, attrs) + (def_id, attrs) }).collect() } @@ -1070,7 +1073,7 @@ fn struct_field_family_to_visibility(family: Family) -> hir::Visibility { } } -pub fn get_struct_field_names(intr: &IdentInterner, cdata: Cmd, id: ast::NodeId) +pub fn get_struct_field_names(intr: &IdentInterner, cdata: Cmd, id: DefIndex) -> Vec { let item = cdata.lookup_item(id); reader::tagged_docs(item, tag_item_field).map(|an_item| { @@ -1228,14 +1231,14 @@ pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Write) -> io::Result<()> // crate to the correct local crate number. pub fn translate_def_id(cdata: Cmd, did: DefId) -> DefId { if did.is_local() { - return DefId { krate: cdata.cnum, xxx_node: did.xxx_node }; + return DefId { krate: cdata.cnum, index: did.index }; } match cdata.cnum_map.borrow().get(&did.krate) { Some(&n) => { DefId { krate: n, - xxx_node: did.xxx_node, + index: did.index, } } None => panic!("didn't find a crate in the cnum_map") @@ -1246,12 +1249,12 @@ pub fn translate_def_id(cdata: Cmd, did: DefId) -> DefId { // for an external crate. fn reverse_translate_def_id(cdata: Cmd, did: DefId) -> Option { if did.krate == cdata.cnum { - return Some(DefId { krate: LOCAL_CRATE, xxx_node: did.xxx_node }); + return Some(DefId { krate: LOCAL_CRATE, index: did.index }); } for (&local, &global) in cdata.cnum_map.borrow().iter() { if global == did.krate { - return Some(DefId { krate: local, xxx_node: did.xxx_node }); + return Some(DefId { krate: local, index: did.index }); } } @@ -1259,7 +1262,7 @@ fn reverse_translate_def_id(cdata: Cmd, did: DefId) -> Option { } pub fn each_inherent_implementation_for_type(cdata: Cmd, - id: ast::NodeId, + id: DefIndex, mut callback: F) where F: FnMut(DefId), { @@ -1277,7 +1280,7 @@ pub fn each_implementation_for_trait(cdata: Cmd, F: FnMut(DefId), { if cdata.cnum == def_id.krate { - let item_doc = cdata.lookup_item(def_id.xxx_node); + let item_doc = cdata.lookup_item(def_id.index); for impl_doc in reader::tagged_docs(item_doc, tag_items_data_item_extension_impl) { callback(item_def_id(impl_doc, cdata)); } @@ -1299,14 +1302,14 @@ pub fn each_implementation_for_trait(cdata: Cmd, } } -pub fn get_trait_of_item(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt) +pub fn get_trait_of_item(cdata: Cmd, id: DefIndex, tcx: &ty::ctxt) -> Option { let item_doc = cdata.lookup_item(id); let parent_item_id = match item_parent_item(cdata, item_doc) { None => return None, Some(item_id) => item_id, }; - let parent_item_doc = cdata.lookup_item(parent_item_id.xxx_node); + let parent_item_doc = cdata.lookup_item(parent_item_id.index); match item_family(parent_item_doc) { Trait => Some(item_def_id(parent_item_doc, cdata)), Impl | DefaultImpl => { @@ -1332,9 +1335,9 @@ pub fn get_native_libraries(cdata: Cmd) }).collect() } -pub fn get_plugin_registrar_fn(data: &[u8]) -> Option { +pub fn get_plugin_registrar_fn(data: &[u8]) -> Option { reader::maybe_get_doc(rbml::Doc::new(data), tag_plugin_registrar_fn) - .map(|doc| reader::doc_as_u32(doc)) + .map(|doc| DefIndex::from_u32(reader::doc_as_u32(doc))) } pub fn each_exported_macro(data: &[u8], intr: &IdentInterner, mut f: F) where @@ -1386,7 +1389,7 @@ pub fn get_missing_lang_items(cdata: Cmd) }).collect() } -pub fn get_method_arg_names(cdata: Cmd, id: ast::NodeId) -> Vec { +pub fn get_method_arg_names(cdata: Cmd, id: DefIndex) -> Vec { let method_doc = cdata.lookup_item(id); match reader::maybe_get_doc(method_doc, tag_method_argument_names) { Some(args_doc) => { @@ -1404,12 +1407,12 @@ pub fn get_reachable_ids(cdata: Cmd) -> Vec { reader::tagged_docs(items, tag_reachable_id).map(|doc| { DefId { krate: cdata.cnum, - xxx_node: reader::doc_as_u32(doc), + index: DefIndex::from_u32(reader::doc_as_u32(doc)), } }).collect() } -pub fn is_typedef(cdata: Cmd, id: ast::NodeId) -> bool { +pub fn is_typedef(cdata: Cmd, id: DefIndex) -> bool { let item_doc = cdata.lookup_item(id); match item_family(item_doc) { Type => true, @@ -1417,7 +1420,7 @@ pub fn is_typedef(cdata: Cmd, id: ast::NodeId) -> bool { } } -pub fn is_const_fn(cdata: Cmd, id: ast::NodeId) -> bool { +pub fn is_const_fn(cdata: Cmd, id: DefIndex) -> bool { let item_doc = cdata.lookup_item(id); match fn_constness(item_doc) { hir::Constness::Const => true, @@ -1425,7 +1428,7 @@ pub fn is_const_fn(cdata: Cmd, id: ast::NodeId) -> bool { } } -pub fn is_impl(cdata: Cmd, id: ast::NodeId) -> bool { +pub fn is_impl(cdata: Cmd, id: DefIndex) -> bool { let item_doc = cdata.lookup_item(id); match item_family(item_doc) { Impl => true, @@ -1445,7 +1448,7 @@ fn doc_generics<'tcx>(base_doc: rbml::Doc, for p in reader::tagged_docs(doc, tag_type_param_def) { let bd = TyDecoder::with_doc(tcx, cdata.cnum, p, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_type_param_def(); types.push(bd.space, bd); } @@ -1467,7 +1470,7 @@ fn doc_generics<'tcx>(base_doc: rbml::Doc, let bounds = reader::tagged_docs(rp_doc, tag_items_data_region).map(|p| { TyDecoder::with_doc(tcx, cdata.cnum, p, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_region() }).collect(); @@ -1497,7 +1500,7 @@ fn doc_predicates<'tcx>(base_doc: rbml::Doc, let data_doc = reader::get_doc(predicate_doc, tag_predicate_data); let data = TyDecoder::with_doc(tcx, cdata.cnum, data_doc, - &mut |_, did| translate_def_id(cdata, did)) + &mut |did| translate_def_id(cdata, did)) .parse_predicate(); predicates.push(space, data); @@ -1506,14 +1509,14 @@ fn doc_predicates<'tcx>(base_doc: rbml::Doc, ty::GenericPredicates { predicates: predicates } } -pub fn is_defaulted_trait(cdata: Cmd, trait_id: ast::NodeId) -> bool { +pub fn is_defaulted_trait(cdata: Cmd, trait_id: DefIndex) -> bool { let trait_doc = cdata.lookup_item(trait_id); assert!(item_family(trait_doc) == Family::Trait); let defaulted_doc = reader::get_doc(trait_doc, tag_defaulted_trait); reader::doc_as_u8(defaulted_doc) != 0 } -pub fn is_default_impl(cdata: Cmd, impl_id: ast::NodeId) -> bool { +pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool { let impl_doc = cdata.lookup_item(impl_id); item_family(impl_doc) == Family::DefaultImpl } @@ -1528,7 +1531,7 @@ pub fn get_imported_filemaps(metadata: &[u8]) -> Vec { }).collect() } -pub fn is_extern_fn(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt) -> bool { +pub fn is_extern_fn(cdata: Cmd, id: DefIndex, tcx: &ty::ctxt) -> bool { let item_doc = match cdata.get_item(id) { Some(doc) => doc, None => return false, @@ -1543,3 +1546,42 @@ pub fn is_extern_fn(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt) -> bool { false } } + +pub fn closure_kind(cdata: Cmd, closure_id: DefIndex) -> ty::ClosureKind { + let closure_doc = cdata.lookup_item(closure_id); + let closure_kind_doc = reader::get_doc(closure_doc, tag_items_closure_kind); + let mut decoder = reader::Decoder::new(closure_kind_doc); + ty::ClosureKind::decode(&mut decoder).unwrap() +} + +pub fn closure_ty<'tcx>(cdata: Cmd, closure_id: DefIndex, tcx: &ty::ctxt<'tcx>) + -> ty::ClosureTy<'tcx> { + let closure_doc = cdata.lookup_item(closure_id); + let closure_ty_doc = reader::get_doc(closure_doc, tag_items_closure_ty); + TyDecoder::with_doc(tcx, cdata.cnum, closure_ty_doc, &mut |did| translate_def_id(cdata, did)) + .parse_closure_ty() +} + +fn def_key(item_doc: rbml::Doc) -> hir_map::DefKey { + match reader::maybe_get_doc(item_doc, tag_def_key) { + Some(def_key_doc) => { + let mut decoder = reader::Decoder::new(def_key_doc); + hir_map::DefKey::decode(&mut decoder).unwrap() + } + None => { + panic!("failed to find block with tag {:?} for item with family {:?}", + tag_def_key, + item_family(item_doc)) + } + } +} + +pub fn def_path(cdata: Cmd, id: DefIndex) -> hir_map::DefPath { + debug!("def_path(id={:?})", id); + hir_map::definitions::make_def_path(id, |parent| { + debug!("def_path: parent={:?}", parent); + let parent_doc = cdata.lookup_item(parent); + def_key(parent_doc) + }) +} + diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 14e5e8b41ffbb..f637545e2e910 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -20,10 +20,10 @@ use metadata::cstore; use metadata::cstore::LOCAL_CRATE; use metadata::decoder; use metadata::tyencode; -use metadata::index::{self, IndexEntry}; +use metadata::index::IndexData; use metadata::inline::InlinedItemRef; use middle::def; -use middle::def_id::DefId; +use middle::def_id::{CRATE_DEF_INDEX, DefId}; use middle::dependency_format::Linkage; use middle::stability; use middle::ty::{self, Ty}; @@ -34,6 +34,7 @@ use std::cell::RefCell; use std::io::prelude::*; use std::io::{Cursor, SeekFrom}; use std::rc::Rc; +use std::u32; use syntax::abi; use syntax::ast::{self, NodeId, Name, CRATE_NODE_ID, CrateNum}; use syntax::attr; @@ -93,6 +94,26 @@ fn encode_def_id(rbml_w: &mut Encoder, id: DefId) { rbml_w.wr_tagged_u64(tag_def_id, def_to_u64(id)); } +/// For every DefId that we create a metadata item for, we include a +/// serialized copy of its DefKey, which allows us to recreate a path. +fn encode_def_id_and_key(ecx: &EncodeContext, + rbml_w: &mut Encoder, + def_id: DefId) +{ + encode_def_id(rbml_w, def_id); + encode_def_key(ecx, rbml_w, def_id); +} + +fn encode_def_key(ecx: &EncodeContext, + rbml_w: &mut Encoder, + def_id: DefId) +{ + rbml_w.start_tag(tag_def_key); + let def_key = ecx.tcx.map.def_key(def_id); + def_key.encode(rbml_w); + rbml_w.end_tag(); +} + fn encode_trait_ref<'a, 'tcx>(rbml_w: &mut Encoder, ecx: &EncodeContext<'a, 'tcx>, trait_ref: ty::TraitRef<'tcx>, @@ -115,11 +136,12 @@ fn encode_family(rbml_w: &mut Encoder, c: char) { } pub fn def_to_u64(did: DefId) -> u64 { - (did.krate as u64) << 32 | (did.xxx_node as u64) + assert!(did.index.as_u32() < u32::MAX); + (did.krate as u64) << 32 | (did.index.as_usize() as u64) } pub fn def_to_string(did: DefId) -> String { - format!("{}:{}", did.krate, did.xxx_node) + format!("{}:{}", did.krate, did.index.as_usize()) } fn encode_item_variances(rbml_w: &mut Encoder, @@ -280,7 +302,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, rbml_w: &mut Encoder, id: NodeId, vis: hir::Visibility, - index: &mut Vec) { + index: &mut IndexData) { debug!("encode_enum_variant_info(id={})", id); let mut disr_val = 0; @@ -297,12 +319,9 @@ fn encode_enum_variant_info(ecx: &EncodeContext, } } - index.push(IndexEntry { - node: vid.xxx_node, - pos: rbml_w.mark_stable_position(), - }); + index.record(vid, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, vid); + encode_def_id_and_key(ecx, rbml_w, vid); encode_family(rbml_w, match variant.kind() { ty::VariantKind::Unit | ty::VariantKind::Tuple => 'v', ty::VariantKind::Dict => 'V' @@ -522,7 +541,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, name: Name, vis: hir::Visibility) { rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, ecx.tcx.map.local_def_id(id)); + encode_def_id_and_key(ecx, rbml_w, ecx.tcx.map.local_def_id(id)); encode_family(rbml_w, 'm'); encode_name(rbml_w, name); debug!("(encoding info for module) encoding info for module ID {}", id); @@ -631,21 +650,17 @@ fn encode_parent_sort(rbml_w: &mut Encoder, sort: char) { fn encode_field<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, rbml_w: &mut Encoder, field: ty::FieldDef<'tcx>, - global_index: &mut Vec) { + global_index: &mut IndexData) { let nm = field.name; let id = ecx.local_id(field.did); - let pos = rbml_w.mark_stable_position(); - global_index.push(IndexEntry { - node: id, - pos: pos, - }); + global_index.record(field.did, rbml_w); rbml_w.start_tag(tag_items_data_item); debug!("encode_field: encoding {} {}", nm, id); encode_struct_field_family(rbml_w, field.vis); encode_name(rbml_w, nm); encode_bounds_and_type_for_item(rbml_w, ecx, id); - encode_def_id(rbml_w, ecx.tcx.map.local_def_id(id)); + encode_def_id_and_key(ecx, rbml_w, field.did); let stab = stability::lookup(ecx.tcx, field.did); encode_stability(rbml_w, stab); @@ -657,15 +672,14 @@ fn encode_info_for_struct_ctor(ecx: &EncodeContext, rbml_w: &mut Encoder, name: Name, ctor_id: NodeId, - index: &mut Vec, + index: &mut IndexData, struct_id: NodeId) { - index.push(IndexEntry { - node: ctor_id, - pos: rbml_w.mark_stable_position(), - }); + let ctor_def_id = ecx.tcx.map.local_def_id(ctor_id); + + index.record(ctor_def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, ecx.tcx.map.local_def_id(ctor_id)); + encode_def_id_and_key(ecx, rbml_w, ctor_def_id); encode_family(rbml_w, 'o'); encode_bounds_and_type_for_item(rbml_w, ecx, ctor_id); encode_name(rbml_w, name); @@ -775,7 +789,7 @@ fn encode_predicates<'a,'tcx>(rbml_w: &mut Encoder, fn encode_method_ty_fields<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, rbml_w: &mut Encoder, method_ty: &ty::Method<'tcx>) { - encode_def_id(rbml_w, method_ty.def_id); + encode_def_id_and_key(ecx, rbml_w, method_ty.def_id); encode_name(rbml_w, method_ty.name); encode_generics(rbml_w, ecx, &method_ty.generics, &method_ty.predicates, tag_method_ty_generics); @@ -802,7 +816,7 @@ fn encode_info_for_associated_const(ecx: &EncodeContext, rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, associated_const.def_id); + encode_def_id_and_key(ecx, rbml_w, associated_const.def_id); encode_name(rbml_w, associated_const.name); encode_visibility(rbml_w, associated_const.vis); encode_family(rbml_w, 'C'); @@ -891,7 +905,7 @@ fn encode_info_for_associated_type<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, associated_type.def_id); + encode_def_id_and_key(ecx, rbml_w, associated_type.def_id); encode_name(rbml_w, associated_type.name); encode_visibility(rbml_w, associated_type.vis); encode_family(rbml_w, 'y'); @@ -1000,19 +1014,11 @@ fn encode_stability(rbml_w: &mut Encoder, stab_opt: Option<&attr::Stability>) { fn encode_info_for_item(ecx: &EncodeContext, rbml_w: &mut Encoder, item: &hir::Item, - index: &mut Vec, + index: &mut IndexData, path: PathElems, vis: hir::Visibility) { let tcx = ecx.tcx; - fn add_to_index(item: &hir::Item, rbml_w: &mut Encoder, - index: &mut Vec) { - index.push(IndexEntry { - node: item.id, - pos: rbml_w.mark_stable_position(), - }); - } - debug!("encoding info for item at {}", tcx.sess.codemap().span_to_string(item.span)); @@ -1021,9 +1027,9 @@ fn encode_info_for_item(ecx: &EncodeContext, match item.node { hir::ItemStatic(_, m, _) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); if m == hir::MutMutable { encode_family(rbml_w, 'b'); } else { @@ -1039,9 +1045,9 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); } hir::ItemConst(_, _) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'C'); encode_bounds_and_type_for_item(rbml_w, ecx, item.id); encode_name(rbml_w, item.name); @@ -1053,9 +1059,9 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); } hir::ItemFn(ref decl, _, constness, _, ref generics, _) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, FN_FAMILY); let tps_len = generics.ty_params.len(); encode_bounds_and_type_for_item(rbml_w, ecx, item.id); @@ -1076,7 +1082,7 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); } hir::ItemMod(ref m) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); encode_info_for_mod(ecx, rbml_w, m, @@ -1087,9 +1093,9 @@ fn encode_info_for_item(ecx: &EncodeContext, item.vis); } hir::ItemForeignMod(ref fm) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'n'); encode_name(rbml_w, item.name); encode_path(rbml_w, path); @@ -1104,9 +1110,9 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); } hir::ItemTy(..) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'y'); encode_bounds_and_type_for_item(rbml_w, ecx, item.id); encode_name(rbml_w, item.name); @@ -1116,10 +1122,10 @@ fn encode_info_for_item(ecx: &EncodeContext, rbml_w.end_tag(); } hir::ItemEnum(ref enum_definition, _) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 't'); encode_item_variances(rbml_w, ecx, item.id); encode_bounds_and_type_for_item(rbml_w, ecx, item.id); @@ -1154,11 +1160,11 @@ fn encode_info_for_item(ecx: &EncodeContext, } /* Index the class*/ - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); /* Now, make an item for the class itself */ rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'S'); encode_bounds_and_type_for_item(rbml_w, ecx, item.id); @@ -1192,9 +1198,9 @@ fn encode_info_for_item(ecx: &EncodeContext, } } hir::ItemDefaultImpl(unsafety, _) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'd'); encode_name(rbml_w, item.name); encode_unsafety(rbml_w, unsafety); @@ -1209,9 +1215,9 @@ fn encode_info_for_item(ecx: &EncodeContext, let impl_items = tcx.impl_items.borrow(); let items = impl_items.get(&def_id).unwrap(); - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'i'); encode_bounds_and_type_for_item(rbml_w, ecx, item.id); encode_name(rbml_w, item.name); @@ -1272,10 +1278,7 @@ fn encode_info_for_item(ecx: &EncodeContext, None }; - index.push(IndexEntry { - node: trait_item_def_id.def_id().xxx_node, - pos: rbml_w.mark_stable_position(), - }); + index.record(trait_item_def_id.def_id(), rbml_w); match tcx.impl_or_trait_item(trait_item_def_id.def_id()) { ty::ConstTraitItem(ref associated_const) => { @@ -1307,9 +1310,9 @@ fn encode_info_for_item(ecx: &EncodeContext, } } hir::ItemTrait(_, _, _, ref ms) => { - add_to_index(item, rbml_w, index); + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, def_id); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_family(rbml_w, 'I'); encode_item_variances(rbml_w, ecx, item.id); let trait_def = tcx.lookup_trait_def(def_id); @@ -1363,10 +1366,7 @@ fn encode_info_for_item(ecx: &EncodeContext, for (i, &item_def_id) in r.iter().enumerate() { assert_eq!(item_def_id.def_id().krate, LOCAL_CRATE); - index.push(IndexEntry { - node: item_def_id.def_id().xxx_node, - pos: rbml_w.mark_stable_position(), - }); + index.record(item_def_id.def_id(), rbml_w); rbml_w.start_tag(tag_items_data_item); @@ -1381,7 +1381,7 @@ fn encode_info_for_item(ecx: &EncodeContext, match trait_item_type { ty::ConstTraitItem(associated_const) => { encode_name(rbml_w, associated_const.name); - encode_def_id(rbml_w, associated_const.def_id); + encode_def_id_and_key(ecx, rbml_w, associated_const.def_id); encode_visibility(rbml_w, associated_const.vis); let elem = ast_map::PathName(associated_const.name); @@ -1422,7 +1422,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } ty::TypeTraitItem(associated_type) => { encode_name(rbml_w, associated_type.name); - encode_def_id(rbml_w, associated_type.def_id); + encode_def_id_and_key(ecx, rbml_w, associated_type.def_id); let elem = ast_map::PathName(associated_type.name); encode_path(rbml_w, @@ -1491,16 +1491,15 @@ fn encode_info_for_item(ecx: &EncodeContext, fn encode_info_for_foreign_item(ecx: &EncodeContext, rbml_w: &mut Encoder, nitem: &hir::ForeignItem, - index: &mut Vec, + index: &mut IndexData, path: PathElems, abi: abi::Abi) { - index.push(IndexEntry { - node: nitem.id, - pos: rbml_w.mark_stable_position(), - }); + let def_id = ecx.tcx.map.local_def_id(nitem.id); + + index.record(def_id, rbml_w); rbml_w.start_tag(tag_items_data_item); - encode_def_id(rbml_w, ecx.tcx.map.local_def_id(nitem.id)); + encode_def_id_and_key(ecx, rbml_w, def_id); encode_visibility(rbml_w, nitem.vis); match nitem.node { hir::ForeignItemFn(ref fndecl, _) => { @@ -1534,12 +1533,39 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext, rbml_w.end_tag(); } -fn my_visit_expr(_e: &hir::Expr) { } +fn my_visit_expr(expr: &hir::Expr, + rbml_w: &mut Encoder, + ecx: &EncodeContext, + index: &mut IndexData) { + match expr.node { + hir::ExprClosure(..) => { + let def_id = ecx.tcx.map.local_def_id(expr.id); + + index.record(def_id, rbml_w); + + rbml_w.start_tag(tag_items_data_item); + encode_def_id_and_key(ecx, rbml_w, def_id); + + rbml_w.start_tag(tag_items_closure_ty); + write_closure_type(ecx, rbml_w, &ecx.tcx.tables.borrow().closure_tys[&def_id]); + rbml_w.end_tag(); + + rbml_w.start_tag(tag_items_closure_kind); + ecx.tcx.closure_kind(def_id).encode(rbml_w).unwrap(); + rbml_w.end_tag(); + + ecx.tcx.map.with_path(expr.id, |path| encode_path(rbml_w, path)); + + rbml_w.end_tag(); + } + _ => { } + } +} fn my_visit_item(i: &hir::Item, rbml_w: &mut Encoder, ecx: &EncodeContext, - index: &mut Vec) { + index: &mut IndexData) { ecx.tcx.map.with_path(i.id, |path| { encode_info_for_item(ecx, rbml_w, i, index, path, i.vis); }); @@ -1548,7 +1574,7 @@ fn my_visit_item(i: &hir::Item, fn my_visit_foreign_item(ni: &hir::ForeignItem, rbml_w: &mut Encoder, ecx: &EncodeContext, - index: &mut Vec) { + index: &mut IndexData) { debug!("writing foreign item {}::{}", ecx.tcx.map.path_to_string(ni.id), ni.name); @@ -1564,40 +1590,32 @@ fn my_visit_foreign_item(ni: &hir::ForeignItem, struct EncodeVisitor<'a, 'b:'a, 'c:'a, 'tcx:'c> { rbml_w_for_visit_item: &'a mut Encoder<'b>, ecx: &'a EncodeContext<'c,'tcx>, - index: &'a mut Vec, + index: &'a mut IndexData, } impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for EncodeVisitor<'a, 'b, 'c, 'tcx> { fn visit_expr(&mut self, ex: &hir::Expr) { visit::walk_expr(self, ex); - my_visit_expr(ex); + my_visit_expr(ex, self.rbml_w_for_visit_item, self.ecx, self.index); } fn visit_item(&mut self, i: &hir::Item) { visit::walk_item(self, i); - my_visit_item(i, - self.rbml_w_for_visit_item, - self.ecx, - self.index); + my_visit_item(i, self.rbml_w_for_visit_item, self.ecx, self.index); } fn visit_foreign_item(&mut self, ni: &hir::ForeignItem) { visit::walk_foreign_item(self, ni); - my_visit_foreign_item(ni, - self.rbml_w_for_visit_item, - self.ecx, - self.index); + my_visit_foreign_item(ni, self.rbml_w_for_visit_item, self.ecx, self.index); } } fn encode_info_for_items(ecx: &EncodeContext, rbml_w: &mut Encoder, krate: &hir::Crate) - -> Vec { - let mut index = Vec::new(); + -> IndexData { + let mut index = IndexData::new(ecx.tcx.map.num_local_def_ids()); + rbml_w.start_tag(tag_items_data); - index.push(IndexEntry { - node: CRATE_NODE_ID, - pos: rbml_w.mark_stable_position(), - }); + index.record_index(CRATE_DEF_INDEX, rbml_w); encode_info_for_mod(ecx, rbml_w, &krate.module, @@ -1617,13 +1635,9 @@ fn encode_info_for_items(ecx: &EncodeContext, index } - - - -fn encode_index(rbml_w: &mut Encoder, index: Vec) -{ +fn encode_index(rbml_w: &mut Encoder, index: IndexData) { rbml_w.start_tag(tag_index); - index::write_index(index, rbml_w.writer); + index.write_index(rbml_w.writer); rbml_w.end_tag(); } @@ -1737,12 +1751,12 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_lang_items); - for (i, &def_id) in ecx.tcx.lang_items.items() { - if let Some(id) = def_id { - if let Some(id) = ecx.tcx.map.as_local_node_id(id) { + for (i, &opt_def_id) in ecx.tcx.lang_items.items() { + if let Some(def_id) = opt_def_id { + if def_id.is_local() { rbml_w.start_tag(tag_lang_items_item); rbml_w.wr_tagged_u32(tag_lang_items_item_id, i as u32); - rbml_w.wr_tagged_u32(tag_lang_items_item_node_id, id as u32); + rbml_w.wr_tagged_u32(tag_lang_items_item_index, def_id.index.as_u32()); rbml_w.end_tag(); } } @@ -1776,7 +1790,10 @@ fn encode_native_libraries(ecx: &EncodeContext, rbml_w: &mut Encoder) { fn encode_plugin_registrar_fn(ecx: &EncodeContext, rbml_w: &mut Encoder) { match ecx.tcx.sess.plugin_registrar_fn.get() { - Some(id) => { rbml_w.wr_tagged_u32(tag_plugin_registrar_fn, id); } + Some(id) => { + let def_id = ecx.tcx.map.local_def_id(id); + rbml_w.wr_tagged_u32(tag_plugin_registrar_fn, def_id.index.as_u32()); + } None => {} } } @@ -1821,24 +1838,26 @@ fn encode_macro_defs(rbml_w: &mut Encoder, rbml_w.end_tag(); } -fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &hir::Crate) { - struct StructFieldVisitor<'a, 'b:'a> { - rbml_w: &'a mut Encoder<'b>, +fn encode_struct_field_attrs(ecx: &EncodeContext, + rbml_w: &mut Encoder, + krate: &hir::Crate) { + struct StructFieldVisitor<'a, 'b:'a, 'c:'a, 'tcx:'b> { + ecx: &'a EncodeContext<'b, 'tcx>, + rbml_w: &'a mut Encoder<'c>, } - impl<'a, 'b, 'v> Visitor<'v> for StructFieldVisitor<'a, 'b> { + impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for StructFieldVisitor<'a, 'b, 'c, 'tcx> { fn visit_struct_field(&mut self, field: &hir::StructField) { self.rbml_w.start_tag(tag_struct_field); - self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id); + let def_id = self.ecx.tcx.map.local_def_id(field.node.id); + encode_def_id(self.rbml_w, def_id); encode_attributes(self.rbml_w, &field.node.attrs); self.rbml_w.end_tag(); } } rbml_w.start_tag(tag_struct_fields); - visit::walk_crate(&mut StructFieldVisitor { - rbml_w: rbml_w - }, krate); + visit::walk_crate(&mut StructFieldVisitor { ecx: ecx, rbml_w: rbml_w }, krate); rbml_w.end_tag(); } @@ -1925,8 +1944,9 @@ fn encode_misc_info(ecx: &EncodeContext, // definition (as that's not defined in this crate). fn encode_reachable(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_reachable_ids); - for id in ecx.reachable { - rbml_w.wr_tagged_u32(tag_reachable_id, *id); + for &id in ecx.reachable { + let def_id = ecx.tcx.map.local_def_id(id); + rbml_w.wr_tagged_u32(tag_reachable_id, def_id.index.as_u32()); } rbml_w.end_tag(); } @@ -2139,7 +2159,7 @@ fn encode_metadata_inner(wr: &mut Cursor>, encode_index(&mut rbml_w, items_index); stats.index_bytes = rbml_w.writer.seek(SeekFrom::Current(0)).unwrap() - i; - encode_struct_field_attrs(&mut rbml_w, krate); + encode_struct_field_attrs(&ecx, &mut rbml_w, krate); stats.total_bytes = rbml_w.writer.seek(SeekFrom::Current(0)).unwrap(); diff --git a/src/librustc/metadata/index.rs b/src/librustc/metadata/index.rs index b02a9022a7a6e..c60b789a2f1bf 100644 --- a/src/librustc/metadata/index.rs +++ b/src/librustc/metadata/index.rs @@ -8,143 +8,95 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use middle::def_id::{DefId, DefIndex}; +use rbml; +use rbml::writer::Encoder; use std::io::{Cursor, Write}; use std::slice; use std::u32; -use syntax::ast::NodeId; -#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord)] -pub struct IndexEntry { - pub node: NodeId, - pub pos: u64 -} - -#[derive(Debug)] -pub struct IndexArrayEntry { - bits: u32, - first_pos: u32 +/// As part of the metadata, we generate an index that stores, for +/// each DefIndex, the position of the corresponding RBML document (if +/// any). This is just a big `[u32]` slice, where an entry of +/// `u32::MAX` indicates that there is no RBML document. This little +/// struct just stores the offsets within the metadata of the start +/// and end of this slice. These are actually part of an RBML +/// document, but for looking things up in the metadata, we just +/// discard the RBML positioning and jump directly to the data. +pub struct Index { + data_start: usize, + data_end: usize, } -impl IndexArrayEntry { - fn encode_to(&self, b: &mut W) { - write_be_u32(b, self.bits); - write_be_u32(b, self.first_pos); +impl Index { + /// Given the RBML doc representing the index, save the offests + /// for later. + pub fn from_rbml(index: rbml::Doc) -> Index { + Index { data_start: index.start, data_end: index.end } } - fn decode_from(b: &[u32]) -> Self { - IndexArrayEntry { - bits: b[0].to_be(), - first_pos: b[1].to_be() + /// Given the metadata, extract out the offset of a particular + /// DefIndex (if any). + #[inline(never)] + pub fn lookup_item(&self, bytes: &[u8], def_index: DefIndex) -> Option { + let words = bytes_to_words(&bytes[self.data_start..self.data_end]); + let index = def_index.as_usize(); + + debug!("lookup_item: index={:?} words.len={:?}", + index, words.len()); + + let position = u32::from_be(words[index]); + if position == u32::MAX { + debug!("lookup_item: position=u32::MAX"); + None + } else { + debug!("lookup_item: position={:?}", position); + Some(position) } } } -/// The Item Index -/// -/// This index maps the NodeId of each item to its location in the -/// metadata. -/// -/// The index is a sparse bit-vector consisting of a index-array -/// and a position-array. Each entry in the index-array handles 32 nodes. -/// The first word is a bit-array consisting of the nodes that hold items, -/// the second is the index of the first of the items in the position-array. -/// If there is a large set of non-item trailing nodes, they can be omitted -/// from the index-array. -/// -/// The index is serialized as an array of big-endian 32-bit words. -/// The first word is the number of items in the position-array. -/// Then, for each item, its position in the metadata follows. -/// After that the index-array is stored. -/// -/// struct index { -/// u32 item_count; -/// u32 items[self.item_count]; -/// struct { u32 bits; u32 offset; } positions[..]; -/// } -pub struct Index { - position_start: usize, - index_start: usize, - index_end: usize, +/// While we are generating the metadata, we also track the position +/// of each DefIndex. It is not required that all definitions appear +/// in the metadata, nor that they are serialized in order, and +/// therefore we first allocate the vector here and fill it with +/// `u32::MAX`. Whenever an index is visited, we fill in the +/// appropriate spot by calling `record_position`. We should never +/// visit the same index twice. +pub struct IndexData { + positions: Vec, } -pub fn write_index(mut entries: Vec, buf: &mut Cursor>) { - assert!(entries.len() < u32::MAX as usize); - entries.sort(); - - let mut last_entry = IndexArrayEntry { bits: 0, first_pos: 0 }; - - write_be_u32(buf, entries.len() as u32); - for &IndexEntry { pos, .. } in &entries { - assert!(pos < u32::MAX as u64); - write_be_u32(buf, pos as u32); +impl IndexData { + pub fn new(max_index: usize) -> IndexData { + IndexData { + positions: vec![u32::MAX; max_index] + } } - let mut pos_in_index_array = 0; - for (i, &IndexEntry { node, .. }) in entries.iter().enumerate() { - let (x, s) = (node / 32 as u32, node % 32 as u32); - while x > pos_in_index_array { - pos_in_index_array += 1; - last_entry.encode_to(buf); - last_entry = IndexArrayEntry { bits: 0, first_pos: i as u32 }; - } - last_entry.bits |= 1< Option { - let ix = (i as usize)*2; - if ix >= index.len() { - None - } else { - Some(IndexArrayEntry::decode_from(&index[ix..ix+2])) - } - } + let position = encoder.mark_stable_position(); - fn item_from_pos(&self, positions: &[u32], pos: u32) -> u32 { - positions[pos as usize].to_be() - } + assert!(position < (u32::MAX as u64)); + let position = position as u32; - #[inline(never)] - pub fn lookup_item(&self, buf: &[u8], node: NodeId) -> Option { - let index = bytes_to_words(&buf[self.index_start..self.index_end]); - let positions = bytes_to_words(&buf[self.position_start..self.index_start]); - let (x, s) = (node / 32 as u32, node % 32 as u32); - let result = match self.lookup_index(index, x) { - Some(IndexArrayEntry { bits, first_pos }) => { - let bit = 1< None // trailing zero - }; - debug!("lookup_item({:?}) = {:?}", node, result); - result + assert!(self.positions[item] == u32::MAX, + "recorded position for item {:?} twice, first at {:?} and now at {:?}", + item, self.positions[item], position); + + self.positions[item] = position; } - pub fn from_buf(buf: &[u8], start: usize, end: usize) -> Self { - let buf = bytes_to_words(&buf[start..end]); - let position_count = buf[0].to_be() as usize; - let position_len = position_count*4; - info!("loaded index - position: {}-{}-{}", start, start+position_len, end); - debug!("index contents are {:?}", - buf.iter().map(|b| format!("{:08x}", b)).collect::>().concat()); - assert!(end-4-start >= position_len); - assert_eq!((end-4-start-position_len)%8, 0); - Index { - position_start: start+4, - index_start: start+position_len+4, - index_end: end + pub fn write_index(&self, buf: &mut Cursor>) { + for &position in &self.positions { + write_be_u32(buf, position); } } } @@ -162,47 +114,3 @@ fn bytes_to_words(b: &[u8]) -> &[u32] { assert!(b.len() % 4 == 0); unsafe { slice::from_raw_parts(b.as_ptr() as *const u32, b.len()/4) } } - -#[test] -fn test_index() { - let entries = vec![ - IndexEntry { node: 0, pos: 17 }, - IndexEntry { node: 31, pos: 29 }, - IndexEntry { node: 32, pos: 1175 }, - IndexEntry { node: 191, pos: 21 }, - IndexEntry { node: 128, pos: 34 }, - IndexEntry { node: 145, pos: 70 }, - IndexEntry { node: 305, pos: 93214 }, - IndexEntry { node: 138, pos: 64 }, - IndexEntry { node: 129, pos: 53 }, - IndexEntry { node: 192, pos: 33334 }, - IndexEntry { node: 200, pos: 80123 }, - ]; - let mut c = Cursor::new(vec![]); - write_index(entries.clone(), &mut c); - let mut buf = c.into_inner(); - let expected: &[u8] = &[ - 0, 0, 0, 11, // # entries - // values: - 0,0,0,17, 0,0,0,29, 0,0,4,151, 0,0,0,34, - 0,0,0,53, 0,0,0,64, 0,0,0,70, 0,0,0,21, - 0,0,130,54, 0,1,56,251, 0,1,108,30, - // index: - 128,0,0,1,0,0,0,0, 0,0,0,1,0,0,0,2, - 0,0,0,0,0,0,0,3, 0,0,0,0,0,0,0,3, - 0,2,4,3,0,0,0,3, 128,0,0,0,0,0,0,7, - 0,0,1,1,0,0,0,8, 0,0,0,0,0,0,0,10, - 0,0,0,0,0,0,0,10, 0,2,0,0,0,0,0,10 - ]; - assert_eq!(buf, expected); - - // insert some junk padding - for i in 0..17 { buf.insert(0, i); buf.push(i) } - let index = Index::from_buf(&buf, 17, buf.len()-17); - - // test round-trip - for i in 0..4096 { - assert_eq!(index.lookup_item(&buf, i), - entries.iter().find(|e| e.node == i).map(|n| n.pos as u32)); - } -} diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index f023049d78f61..4657323c1726d 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -16,11 +16,9 @@ #![allow(non_camel_case_types)] -pub use self::DefIdSource::*; - use rustc_front::hir; -use middle::def_id::DefId; +use middle::def_id::{DefId, DefIndex}; use middle::region; use middle::subst; use middle::subst::VecPerParamSpace; @@ -36,32 +34,7 @@ use syntax::parse::token; // parse_from_str. Extra parameters are for converting to/from def_ids in the // data buffer. Whatever format you choose should not contain pipe characters. -// Def id conversion: when we encounter def-ids, they have to be translated. -// For example, the crate number must be converted from the crate number used -// in the library we are reading from into the local crate numbers in use -// here. To perform this translation, the type decoder is supplied with a -// conversion function of type `conv_did`. -// -// Sometimes, particularly when inlining, the correct translation of the -// def-id will depend on where it originated from. Therefore, the conversion -// function is given an indicator of the source of the def-id. See -// astencode.rs for more information. -#[derive(Copy, Clone, Debug)] -pub enum DefIdSource { - // Identifies a struct, trait, enum, etc. - NominalType, - - // Identifies a type alias (`type X = ...`). - TypeWithId, - - // Identifies a region parameter (`fn foo<'X>() { ... }`). - RegionParameter, - - // Identifies a closure - ClosureSource -} - -pub type DefIdConvert<'a> = &'a mut FnMut(DefIdSource, DefId) -> DefId; +pub type DefIdConvert<'a> = &'a mut FnMut(DefId) -> DefId; pub struct TyDecoder<'a, 'tcx: 'a> { data: &'a [u8], @@ -183,7 +156,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { ty::BrAnon(id) } '[' => { - let def = self.parse_def(RegionParameter); + let def = self.parse_def(); let name = token::intern(&self.parse_str(']')); ty::BrNamed(def, name) } @@ -209,7 +182,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { } 'B' => { assert_eq!(self.next(), '['); - let def_id = self.parse_def(NominalType); + let def_id = self.parse_def(); let space = self.parse_param_space(); assert_eq!(self.next(), '|'); let index = self.parse_u32(); @@ -309,7 +282,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { } pub fn parse_trait_ref(&mut self) -> ty::TraitRef<'tcx> { - let def = self.parse_def(NominalType); + let def = self.parse_def(); let substs = self.tcx.mk_substs(self.parse_substs()); ty::TraitRef {def_id: def, substs: substs} } @@ -338,7 +311,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { 'c' => return tcx.types.char, 't' => { assert_eq!(self.next(), '['); - let did = self.parse_def(NominalType); + let did = self.parse_def(); let substs = self.parse_substs(); assert_eq!(self.next(), ']'); let def = self.tcx.lookup_adt_def(did); @@ -385,7 +358,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { return tcx.mk_tup(params); } 'F' => { - let def_id = self.parse_def(NominalType); + let def_id = self.parse_def(); return tcx.mk_fn(Some(def_id), tcx.mk_bare_fn(self.parse_bare_fn_ty())); } 'G' => { @@ -427,13 +400,13 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { return tt; } '\"' => { - let _ = self.parse_def(TypeWithId); + let _ = self.parse_def(); let inner = self.parse_ty(); inner } 'a' => { assert_eq!(self.next(), '['); - let did = self.parse_def(NominalType); + let did = self.parse_def(); let substs = self.parse_substs(); assert_eq!(self.next(), ']'); let def = self.tcx.lookup_adt_def(did); @@ -441,7 +414,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { } 'k' => { assert_eq!(self.next(), '['); - let did = self.parse_def(ClosureSource); + let did = self.parse_def(); let substs = self.parse_substs(); let mut tys = vec![]; while self.peek() != '.' { @@ -476,9 +449,9 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { ty::TypeAndMut { ty: self.parse_ty(), mutbl: m } } - fn parse_def(&mut self, source: DefIdSource) -> DefId { + fn parse_def(&mut self) -> DefId { let def_id = parse_defid(self.scan(|c| c == '|')); - return (self.conv_def_id)(source, def_id); + return (self.conv_def_id)(def_id); } fn parse_uint(&mut self) -> usize { @@ -581,7 +554,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { 'p' => ty::Binder(self.parse_projection_predicate()).to_predicate(), 'w' => ty::Predicate::WellFormed(self.parse_ty()), 'O' => { - let def_id = self.parse_def(NominalType); + let def_id = self.parse_def(); assert_eq!(self.next(), '|'); ty::Predicate::ObjectSafe(def_id) } @@ -601,12 +574,12 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { pub fn parse_type_param_def(&mut self) -> ty::TypeParameterDef<'tcx> { let name = self.parse_name(':'); - let def_id = self.parse_def(NominalType); + let def_id = self.parse_def(); let space = self.parse_param_space(); assert_eq!(self.next(), '|'); let index = self.parse_u32(); assert_eq!(self.next(), '|'); - let default_def_id = self.parse_def(NominalType); + let default_def_id = self.parse_def(); let default = self.parse_opt(|this| this.parse_ty()); let object_lifetime_default = self.parse_object_lifetime_default(); @@ -623,7 +596,7 @@ impl<'a,'tcx> TyDecoder<'a,'tcx> { pub fn parse_region_param_def(&mut self) -> ty::RegionParameterDef { let name = self.parse_name(':'); - let def_id = self.parse_def(NominalType); + let def_id = self.parse_def(); let space = self.parse_param_space(); assert_eq!(self.next(), '|'); let index = self.parse_u32(); @@ -731,11 +704,12 @@ fn parse_defid(buf: &[u8]) -> DefId { let def_num = match str::from_utf8(def_part).ok().and_then(|s| { s.parse::().ok() }) { - Some(dn) => dn as ast::NodeId, + Some(dn) => dn, None => panic!("internal error: parse_defid: id expected, found {:?}", def_part) }; - DefId { krate: crate_num, xxx_node: def_num } + let index = DefIndex::new(def_num); + DefId { krate: crate_num, index: index } } fn parse_unsafety(c: char) -> hir::Unsafety { diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 02bd9951d341a..672ae5d3fb69c 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -19,14 +19,11 @@ use rustc_front::fold::Folder; use metadata::common as c; use metadata::cstore as cstore; -use metadata::cstore::LOCAL_CRATE; use session::Session; use metadata::decoder; use metadata::encoder as e; use metadata::inline::{InlinedItem, InlinedItemRef}; use metadata::tydecode; -use metadata::tydecode::{DefIdSource, NominalType, TypeWithId}; -use metadata::tydecode::{RegionParameter, ClosureSource}; use metadata::tyencode; use middle::ty::adjustment; use middle::ty::cast; @@ -73,10 +70,6 @@ trait tr { fn tr(&self, dcx: &DecodeContext) -> Self; } -trait tr_intern { - fn tr_intern(&self, dcx: &DecodeContext) -> DefId; -} - // ______________________________________________________________________ // Top-level methods. @@ -130,10 +123,12 @@ impl<'a, 'b, 'c, 'tcx> ast_map::FoldOps for &'a DecodeContext<'b, 'c, 'tcx> { pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata, tcx: &ty::ctxt<'tcx>, path: Vec, + def_path: ast_map::DefPath, par_doc: rbml::Doc) - -> Result<&'tcx InlinedItem, Vec> { + -> Result<&'tcx InlinedItem, (Vec, + ast_map::DefPath)> { match par_doc.opt_child(c::tag_ast) { - None => Err(path), + None => Err((path, def_path)), Some(ast_doc) => { let mut path_as_str = None; debug!("> Decoding inlined fn: {:?}::?", @@ -154,7 +149,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata, last_filemap_index: Cell::new(0) }; let raw_ii = decode_ast(ast_doc); - let ii = ast_map::map_decoded_item(&dcx.tcx.map, path, raw_ii, dcx); + let ii = ast_map::map_decoded_item(&dcx.tcx.map, path, def_path, raw_ii, dcx); let name = match *ii { InlinedItem::Item(ref i) => i.name, @@ -214,24 +209,10 @@ impl<'a, 'b, 'tcx> DecodeContext<'a, 'b, 'tcx> { /// be inlined. Note that even when the inlined function is referencing itself recursively, we /// would want `tr_def_id` for that reference--- conceptually the function calls the original, /// non-inlined version, and trans deals with linking that recursive call to the inlined copy. - /// - /// However, there are a *few* cases where def-ids are used but we know that the thing being - /// referenced is in fact *internal* to the item being inlined. In those cases, you should use - /// `tr_intern_def_id()` below. pub fn tr_def_id(&self, did: DefId) -> DefId { - decoder::translate_def_id(self.cdata, did) } - /// Translates an INTERNAL def-id, meaning a def-id that is - /// known to refer to some part of the item currently being - /// inlined. In that case, we want to convert the def-id to - /// refer to the current crate and to the new, inlined node-id. - pub fn tr_intern_def_id(&self, did: DefId) -> DefId { - assert_eq!(did.krate, LOCAL_CRATE); - DefId { krate: LOCAL_CRATE, xxx_node: self.tr_id(did.xxx_node) } - } - /// Translates a `Span` from an extern crate to the corresponding `Span` /// within the local crate's codemap. `creader::import_codemap()` will /// already have allocated any additionally needed FileMaps in the local @@ -290,12 +271,6 @@ impl<'a, 'b, 'tcx> DecodeContext<'a, 'b, 'tcx> { } } -impl tr_intern for DefId { - fn tr_intern(&self, dcx: &DecodeContext) -> DefId { - dcx.tr_intern_def_id(*self) - } -} - impl tr for DefId { fn tr(&self, dcx: &DecodeContext) -> DefId { dcx.tr_def_id(*self) @@ -575,10 +550,6 @@ impl<'a, 'tcx> read_method_callee_helper<'tcx> for reader::Decoder<'a> { } } -pub fn encode_closure_kind(ebml_w: &mut Encoder, kind: ty::ClosureKind) { - kind.encode(ebml_w).unwrap(); -} - pub fn encode_cast_kind(ebml_w: &mut Encoder, kind: cast::CastKind) { kind.encode(ebml_w).unwrap(); } @@ -632,8 +603,6 @@ impl<'a, 'tcx> get_ty_str_ctxt<'tcx> for e::EncodeContext<'a, 'tcx> { } trait rbml_writer_helpers<'tcx> { - fn emit_closure_type<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, - closure_type: &ty::ClosureTy<'tcx>); fn emit_region(&mut self, ecx: &e::EncodeContext, r: ty::Region); fn emit_ty<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, ty: Ty<'tcx>); fn emit_tys<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, tys: &[Ty<'tcx>]); @@ -662,14 +631,6 @@ trait rbml_writer_helpers<'tcx> { } impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> { - fn emit_closure_type<'b>(&mut self, - ecx: &e::EncodeContext<'b, 'tcx>, - closure_type: &ty::ClosureTy<'tcx>) { - self.emit_opaque(|this| { - Ok(e::write_closure_type(ecx, this, closure_type)) - }); - } - fn emit_region(&mut self, ecx: &e::EncodeContext, r: ty::Region) { self.emit_opaque(|this| Ok(e::write_region(ecx, this, r))); } @@ -1005,24 +966,6 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - if let Some(def_id) = opt_def_id { - if let Some(closure_type) = tcx.tables.borrow().closure_tys.get(&def_id) { - rbml_w.tag(c::tag_table_closure_tys, |rbml_w| { - rbml_w.id(id); - rbml_w.emit_closure_type(ecx, closure_type); - }) - } - } - - if let Some(def_id) = opt_def_id { - if let Some(closure_kind) = tcx.tables.borrow().closure_kinds.get(&def_id) { - rbml_w.tag(c::tag_table_closure_kinds, |rbml_w| { - rbml_w.id(id); - encode_closure_kind(rbml_w, *closure_kind) - }) - } - } - if let Some(cast_kind) = tcx.cast_kinds.borrow().get(&id) { rbml_w.tag(c::tag_table_cast_kinds, |rbml_w| { rbml_w.id(id); @@ -1080,17 +1023,12 @@ trait rbml_decoder_decoder_helpers<'tcx> { -> adjustment::AutoAdjustment<'tcx>; fn read_cast_kind<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> cast::CastKind; - fn read_closure_kind<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) - -> ty::ClosureKind; - fn read_closure_ty<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) - -> ty::ClosureTy<'tcx>; fn read_auto_deref_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> adjustment::AutoDerefRef<'tcx>; fn read_autoref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> adjustment::AutoRef<'tcx>; fn convert_def_id(&mut self, dcx: &DecodeContext, - source: DefIdSource, did: DefId) -> DefId; @@ -1114,7 +1052,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { self.read_opaque(|_, doc| { Ok( tydecode::TyDecoder::with_doc(tcx, cdata.cnum, doc, - &mut |_, id| decoder::translate_def_id(cdata, id)) + &mut |id| decoder::translate_def_id(cdata, id)) .parse_ty()) }).unwrap() } @@ -1136,7 +1074,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { self.read_opaque(|_, doc| { Ok( tydecode::TyDecoder::with_doc(tcx, cdata.cnum, doc, - &mut |_, id| decoder::translate_def_id(cdata, id)) + &mut |id| decoder::translate_def_id(cdata, id)) .parse_substs()) }).unwrap() } @@ -1149,7 +1087,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { Ok(op( &mut tydecode::TyDecoder::with_doc( dcx.tcx, dcx.cdata.cnum, doc, - &mut |s, a| this.convert_def_id(dcx, s, a)))) + &mut |a| this.convert_def_id(dcx, a)))) }).unwrap(); fn type_string(doc: rbml::Doc) -> String { @@ -1238,7 +1176,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { -> subst::Substs<'tcx> { self.read_opaque(|this, doc| { Ok(tydecode::TyDecoder::with_doc(dcx.tcx, dcx.cdata.cnum, doc, - &mut |s, a| this.convert_def_id(dcx, s, a)) + &mut |a| this.convert_def_id(dcx, a)) .parse_substs()) }).unwrap() } @@ -1345,18 +1283,6 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { Decodable::decode(self).unwrap() } - fn read_closure_kind<'b, 'c>(&mut self, _dcx: &DecodeContext<'b, 'c, 'tcx>) - -> ty::ClosureKind - { - Decodable::decode(self).unwrap() - } - - fn read_closure_ty<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>) - -> ty::ClosureTy<'tcx> - { - self.read_ty_encoded(dcx, |decoder| decoder.parse_closure_ty()) - } - /// Converts a def-id that appears in a type. The correct /// translation will depend on what kind of def-id this is. /// This is a subtle point: type definitions are not @@ -1391,14 +1317,10 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> { /// def-ids so that all these distinctions were unnecessary. fn convert_def_id(&mut self, dcx: &DecodeContext, - source: tydecode::DefIdSource, did: DefId) -> DefId { - let r = match source { - NominalType | TypeWithId | RegionParameter => dcx.tr_def_id(did), - ClosureSource => dcx.tr_intern_def_id(did) - }; - debug!("convert_def_id(source={:?}, did={:?})={:?}", source, did, r); + let r = dcx.tr_def_id(did); + debug!("convert_def_id(did={:?})={:?}", did, r); return r; } } @@ -1485,20 +1407,6 @@ fn decode_side_tables(dcx: &DecodeContext, val_dsr.read_auto_adjustment(dcx); dcx.tcx.tables.borrow_mut().adjustments.insert(id, adj); } - c::tag_table_closure_tys => { - let closure_ty = - val_dsr.read_closure_ty(dcx); - dcx.tcx.tables.borrow_mut().closure_tys.insert( - dcx.tcx.map.local_def_id(id), - closure_ty); - } - c::tag_table_closure_kinds => { - let closure_kind = - val_dsr.read_closure_kind(dcx); - dcx.tcx.tables.borrow_mut().closure_kinds.insert( - dcx.tcx.map.local_def_id(id), - closure_kind); - } c::tag_table_cast_kinds => { let cast_kind = val_dsr.read_cast_kind(dcx); diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 00cfbf2dfe2c2..91d9f70aee9a7 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -92,7 +92,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, let expr_id = match csearch::maybe_get_item_ast( tcx, enum_def, - Box::new(|a, b, c, d| astencode::decode_inlined_item(a, b, c, d))) + Box::new(|a, b, c, d, e| astencode::decode_inlined_item(a, b, c, d, e))) { csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => match item.node { hir::ItemEnum(hir::EnumDef { .. }, _) => { @@ -168,7 +168,7 @@ pub fn lookup_const_by_id<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>, } let mut used_ref_id = false; let expr_id = match csearch::maybe_get_item_ast(tcx, def_id, - Box::new(|a, b, c, d| astencode::decode_inlined_item(a, b, c, d))) { + Box::new(|a, b, c, d, e| astencode::decode_inlined_item(a, b, c, d, e))) { csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => match item.node { hir::ItemConst(_, ref const_expr) => Some(const_expr.id), _ => None @@ -224,7 +224,7 @@ fn inline_const_fn_from_external_crate(tcx: &ty::ctxt, def_id: DefId) } let fn_id = match csearch::maybe_get_item_ast(tcx, def_id, - box |a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) { + box |a, b, c, d, e| astencode::decode_inlined_item(a, b, c, d, e)) { csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => Some(item.id), csearch::FoundAst::Found(&InlinedItem::ImplItem(_, ref item)) => Some(item.id), _ => None diff --git a/src/librustc/middle/def_id.rs b/src/librustc/middle/def_id.rs index f8f3412c8bb2c..ed7a1d75a52e9 100644 --- a/src/librustc/middle/def_id.rs +++ b/src/librustc/middle/def_id.rs @@ -10,20 +10,53 @@ use metadata::cstore::LOCAL_CRATE; use middle::ty; -use syntax::ast::{CrateNum, NodeId}; +use syntax::ast::CrateNum; use std::fmt; +use std::u32; +/// A DefIndex is an index into the hir-map for a crate, identifying a +/// particular definition. It should really be considered an interned +/// shorthand for a particular DefPath. +#[derive(Clone, Debug, Eq, Ord, PartialOrd, PartialEq, RustcEncodable, + RustcDecodable, Hash, Copy)] +pub struct DefIndex(u32); + +impl DefIndex { + pub fn new(x: usize) -> DefIndex { + assert!(x < (u32::MAX as usize)); + DefIndex(x as u32) + } + + pub fn from_u32(x: u32) -> DefIndex { + DefIndex(x) + } + + pub fn as_usize(&self) -> usize { + self.0 as usize + } + + pub fn as_u32(&self) -> u32 { + self.0 + } +} + +/// The crate root is always assigned index 0 by the AST Map code, +/// thanks to `NodeCollector::new`. +pub const CRATE_DEF_INDEX: DefIndex = DefIndex(0); + +/// A DefId identifies a particular *definition*, by combining a crate +/// index and a def index. #[derive(Clone, Eq, Ord, PartialOrd, PartialEq, RustcEncodable, RustcDecodable, Hash, Copy)] pub struct DefId { pub krate: CrateNum, - pub xxx_node: NodeId, + pub index: DefIndex, } impl fmt::Debug for DefId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "DefId {{ krate: {}, node: {}", - self.krate, self.xxx_node)); + try!(write!(f, "DefId {{ krate: {:?}, node: {:?}", + self.krate, self.index)); // Unfortunately, there seems to be no way to attempt to print // a path for a def-id, so I'll just make a best effort for now @@ -41,8 +74,8 @@ impl fmt::Debug for DefId { impl DefId { - pub fn xxx_local(id: NodeId) -> DefId { - DefId { krate: LOCAL_CRATE, xxx_node: id } + pub fn local(index: DefIndex) -> DefId { + DefId { krate: LOCAL_CRATE, index: index } } pub fn is_local(&self) -> bool { diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 512faa8f8b534..1eed7fb95a1f5 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -276,7 +276,7 @@ enum PassArgs { } impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { - pub fn new(delegate: &'d mut Delegate<'tcx>, + pub fn new(delegate: &'d mut (Delegate<'tcx>), typer: &'t infer::InferCtxt<'a, 'tcx>) -> ExprUseVisitor<'d,'t,'a,'tcx> where 'tcx:'a { diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 3def56f94a181..3b44dc12ac197 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -1455,7 +1455,15 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { def_id: DefId) -> Option { - self.tables.borrow().closure_kinds.get(&def_id).cloned() + if def_id.is_local() { + self.tables.borrow().closure_kinds.get(&def_id).cloned() + } else { + // During typeck, ALL closures are local. But afterwards, + // during trans, we see closure ids from other traits. + // That may require loading the closure data out of the + // cstore. + Some(ty::Tables::closure_kind(&self.tables, self.tcx, def_id)) + } } pub fn closure_type(&self, @@ -1463,12 +1471,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { substs: &ty::ClosureSubsts<'tcx>) -> ty::ClosureTy<'tcx> { - let closure_ty = self.tables - .borrow() - .closure_tys - .get(&def_id) - .unwrap() - .subst(self.tcx, &substs.func_substs); + let closure_ty = + ty::Tables::closure_type(self.tables, + self.tcx, + def_id, + substs); if self.normalize { normalize_associated_type(&self.tcx, &closure_ty) diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 73313a5c257a6..03c75fc6cc370 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -208,8 +208,8 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { pub fn collect_external_language_items(&mut self) { 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 = DefId { krate: crate_number, xxx_node: node_id }; + each_lang_item(crate_store, crate_number, |index, item_index| { + let def_id = DefId { krate: crate_number, index: index }; self.collect_item(item_index, def_id, DUMMY_SP); true }); diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 73519b8f579d5..be227e620b881 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -15,7 +15,7 @@ use session::Session; use lint; use metadata::cstore::LOCAL_CRATE; use middle::def; -use middle::def_id::DefId; +use middle::def_id::{CRATE_DEF_INDEX, DefId}; use middle::ty; use middle::privacy::PublicItems; use metadata::csearch; @@ -383,7 +383,7 @@ pub fn check_item(tcx: &ty::ctxt, item: &hir::Item, warn_about_defns: bool, Some(cnum) => cnum, None => return, }; - let id = DefId { krate: cnum, xxx_node: ast::CRATE_NODE_ID }; + let id = DefId { krate: cnum, index: CRATE_DEF_INDEX }; maybe_do_stability_check(tcx, id, item.span, cb); } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 5e12e77435a12..60f6cffa346af 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -37,7 +37,6 @@ use super::{VtableImplData, VtableObjectData, VtableBuiltinData, use super::object_safety; use super::util; -use metadata::cstore::LOCAL_CRATE; use middle::def_id::DefId; use middle::infer; use middle::infer::{InferCtxt, TypeFreshener}; @@ -1720,7 +1719,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet ty::TyTuple(ref tys) => ok_if(tys.clone()), - ty::TyClosure(def_id, ref substs) => { + ty::TyClosure(_, ref substs) => { // FIXME -- This case is tricky. In the case of by-ref // closures particularly, we need the results of // inference to decide how to reflect the type of each @@ -1730,7 +1729,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // captures are by value. Really what we ought to do // is reserve judgement and then intertwine this // analysis with closure inference. - assert_eq!(def_id.krate, LOCAL_CRATE); // Unboxed closures shouldn't be // implicitly copyable @@ -1864,7 +1862,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { tys.clone() } - ty::TyClosure(def_id, ref substs) => { + ty::TyClosure(_, ref substs) => { // FIXME(#27086). We are invariant w/r/t our // substs.func_substs, but we don't see them as // constituent types; this seems RIGHT but also like @@ -1873,7 +1871,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // OIBIT interact? That is, there is no way to say // "make me invariant with respect to this TYPE, but // do not act as though I can reach it" - assert_eq!(def_id.krate, LOCAL_CRATE); substs.upvar_tys.clone() } diff --git a/src/librustc/middle/ty/context.rs b/src/librustc/middle/ty/context.rs index 57f04af2ba913..906ff5b2656e7 100644 --- a/src/librustc/middle/ty/context.rs +++ b/src/librustc/middle/ty/context.rs @@ -16,6 +16,7 @@ use front::map as ast_map; use session::Session; use lint; +use metadata::csearch; use middle; use middle::def::DefMap; use middle::def_id::DefId; @@ -134,6 +135,40 @@ impl<'tcx> Tables<'tcx> { closure_kinds: DefIdMap(), } } + + pub fn closure_kind(this: &RefCell, + tcx: &ty::ctxt<'tcx>, + def_id: DefId) + -> ty::ClosureKind { + // If this is a local def-id, it should be inserted into the + // tables by typeck; else, it will be retreived from + // the external crate metadata. + if let Some(&kind) = this.borrow().closure_kinds.get(&def_id) { + return kind; + } + + let kind = csearch::closure_kind(tcx, def_id); + this.borrow_mut().closure_kinds.insert(def_id, kind); + kind + } + + pub fn closure_type(this: &RefCell, + tcx: &ty::ctxt<'tcx>, + def_id: DefId, + substs: &ClosureSubsts<'tcx>) + -> ty::ClosureTy<'tcx> + { + // If this is a local def-id, it should be inserted into the + // tables by typeck; else, it will be retreived from + // the external crate metadata. + if let Some(ty) = this.borrow().closure_tys.get(&def_id) { + return ty.subst(tcx, &substs.func_substs); + } + + let ty = csearch::closure_ty(tcx, def_id); + this.borrow_mut().closure_tys.insert(def_id, ty.clone()); + ty.subst(tcx, &substs.func_substs) + } } impl<'tcx> CommonTypes<'tcx> { @@ -336,19 +371,8 @@ pub struct ctxt<'tcx> { /// constitute it. pub fragment_infos: RefCell>>, } -impl<'tcx> ctxt<'tcx> { - pub fn closure_kind(&self, def_id: DefId) -> ty::ClosureKind { - *self.tables.borrow().closure_kinds.get(&def_id).unwrap() - } - - pub fn closure_type(&self, - def_id: DefId, - substs: &ClosureSubsts<'tcx>) - -> ty::ClosureTy<'tcx> - { - self.tables.borrow().closure_tys.get(&def_id).unwrap().subst(self, &substs.func_substs) - } +impl<'tcx> ctxt<'tcx> { pub fn type_parameter_def(&self, node_id: NodeId) -> ty::TypeParameterDef<'tcx> diff --git a/src/librustc/middle/ty/mod.rs b/src/librustc/middle/ty/mod.rs index 1b334e3772244..315268fd0b626 100644 --- a/src/librustc/middle/ty/mod.rs +++ b/src/librustc/middle/ty/mod.rs @@ -2263,6 +2263,14 @@ impl<'tcx> ctxt<'tcx> { self.with_path(id, |path| ast_map::path_to_string(path)) } + pub fn def_path(&self, id: DefId) -> ast_map::DefPath { + if id.is_local() { + self.map.def_path(id) + } else { + csearch::def_path(self, id) + } + } + pub fn with_path(&self, id: DefId, f: F) -> T where F: FnOnce(ast_map::PathElems) -> T, { @@ -2480,6 +2488,18 @@ impl<'tcx> ctxt<'tcx> { def.flags.set(def.flags.get() | TraitFlags::IMPLS_VALID); } + pub fn closure_kind(&self, def_id: DefId) -> ty::ClosureKind { + Tables::closure_kind(&self.tables, self, def_id) + } + + pub fn closure_type(&self, + def_id: DefId, + substs: &ClosureSubsts<'tcx>) + -> ty::ClosureTy<'tcx> + { + Tables::closure_type(&self.tables, self, def_id, substs) + } + /// Given the def_id of an impl, return the def_id of the trait it implements. /// If it implements no trait, return `None`. pub fn trait_id_of_impl(&self, def_id: DefId) -> Option { @@ -2800,3 +2820,4 @@ pub trait HasTypeFlags { !self.has_type_flags(TypeFlags::HAS_LOCAL_NAMES) } } + diff --git a/src/librustc/middle/ty/util.rs b/src/librustc/middle/ty/util.rs index 2e6cc4faff8d0..b546438f392a0 100644 --- a/src/librustc/middle/ty/util.rs +++ b/src/librustc/middle/ty/util.rs @@ -461,7 +461,7 @@ impl<'tcx> ty::ctxt<'tcx> { tcx.sess.cstore.get_crate_hash(did.krate) }; h.as_str().hash(state); - did.xxx_node.hash(state); + did.index.hash(state); }; let mt = |state: &mut SipHasher, mt: TypeAndMut| { mt.mutbl.hash(state); diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index de356e54699c1..67ced5d32594d 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -27,7 +27,7 @@ use std::fmt; use syntax::abi; use syntax::ast; use syntax::parse::token; -use syntax::ast::{CRATE_NODE_ID}; +use syntax::ast::CRATE_NODE_ID; use rustc_front::hir; pub fn verbose() -> bool { diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index d05b5b3e8606a..1df3c1609b890 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -901,20 +901,22 @@ impl LateLintPass for UnconditionalRecursion { fn expr_refers_to_this_method(tcx: &ty::ctxt, method: &ty::Method, id: ast::NodeId) -> bool { - let tables = tcx.tables.borrow(); - // Check for method calls and overloaded operators. - if let Some(m) = tables.method_map.get(&ty::MethodCall::expr(id)) { + let opt_m = tcx.tables.borrow().method_map.get(&ty::MethodCall::expr(id)).cloned(); + if let Some(m) = opt_m { if method_call_refers_to_method(tcx, method, m.def_id, m.substs, id) { return true; } } // Check for overloaded autoderef method calls. - if let Some(&adjustment::AdjustDerefRef(ref adj)) = tables.adjustments.get(&id) { + let opt_adj = tcx.tables.borrow().adjustments.get(&id).cloned(); + if let Some(adjustment::AdjustDerefRef(adj)) = opt_adj { for i in 0..adj.autoderefs { let method_call = ty::MethodCall::autoderef(id, i as u32); - if let Some(m) = tables.method_map.get(&method_call) { + if let Some(m) = tcx.tables.borrow().method_map + .get(&method_call) + .cloned() { if method_call_refers_to_method(tcx, method, m.def_id, m.substs, id) { return true; } @@ -927,9 +929,13 @@ impl LateLintPass for UnconditionalRecursion { hir_map::NodeExpr(&hir::Expr { node: hir::ExprCall(ref callee, _), .. }) => { match tcx.def_map.borrow().get(&callee.id).map(|d| d.full_def()) { Some(def::DefMethod(def_id)) => { - let no_substs = &ty::ItemSubsts::empty(); - let ts = tables.item_substs.get(&callee.id).unwrap_or(no_substs); - method_call_refers_to_method(tcx, method, def_id, &ts.substs, id) + let item_substs = + tcx.tables.borrow().item_substs + .get(&callee.id) + .cloned() + .unwrap_or_else(|| ty::ItemSubsts::empty()); + method_call_refers_to_method( + tcx, method, def_id, &item_substs.substs, id) } _ => false } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index c50cb5960b1ff..f74144565fc58 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -34,7 +34,7 @@ use self::NamespaceError::*; use rustc::metadata::csearch; use rustc::metadata::decoder::{DefLike, DlDef, DlField, DlImpl}; use rustc::middle::def::*; -use rustc::middle::def_id::DefId; +use rustc::middle::def_id::{CRATE_DEF_INDEX, DefId}; use syntax::ast::{Name, NodeId}; use syntax::attr::AttrMetaMethods; @@ -387,7 +387,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { ItemExternCrate(_) => { // n.b. we don't need to look at the path option here, because cstore already did if let Some(crate_id) = self.session.cstore.find_extern_mod_stmt_cnum(item.id) { - let def_id = DefId { krate: crate_id, xxx_node: 0 }; + let def_id = DefId { krate: crate_id, index: CRATE_DEF_INDEX }; self.external_exports.insert(def_id); let parent_link = ModuleParentLink(Rc::downgrade(parent), name); let external_module = Rc::new(Module::new(parent_link, diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 2e18b50a45cfe..eaa947150b04e 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -25,7 +25,7 @@ use metadata::loader::METADATA_FILENAME; use metadata::{encoder, cstore, filesearch, csearch, creader}; use middle::dependency_format::Linkage; use middle::ty::{self, Ty}; -use rustc::front::map::{PathElem, PathElems, PathName}; +use rustc::front::map::DefPath; use trans::{CrateContext, CrateTranslation, gensym_name}; use util::common::time; use util::sha2::{Digest, Sha256}; @@ -36,6 +36,7 @@ use std::env; use std::ffi::OsString; use std::fs::{self, PathExt}; use std::io::{self, Read, Write}; +use std::iter::once; use std::mem; use std::path::{Path, PathBuf}; use std::process::Command; @@ -44,7 +45,7 @@ use flate; use serialize::hex::ToHex; use syntax::ast; use syntax::codemap::Span; -use syntax::parse::token; +use syntax::parse::token::{self, InternedString}; use syntax::attr::AttrMetaMethods; use rustc_front::hir; @@ -284,8 +285,7 @@ pub fn sanitize(s: &str) -> String { return result; } -pub fn mangle>(path: PI, - hash: Option<&str>) -> String { +pub fn mangle>(path: PI, hash: Option<&str>) -> String { // Follow C++ namespace-mangling style, see // http://en.wikipedia.org/wiki/Name_mangling for more info. // @@ -308,8 +308,8 @@ pub fn mangle>(path: PI, } // First, connect each component with pairs. - for e in path { - push(&mut n, &e.name().as_str()) + for data in path { + push(&mut n, &data); } match hash { @@ -321,11 +321,13 @@ pub fn mangle>(path: PI, n } -pub fn exported_name(path: PathElems, hash: &str) -> String { +pub fn exported_name(path: DefPath, hash: &str) -> String { + let path = path.into_iter() + .map(|e| e.data.as_interned_str()); mangle(path, Some(hash)) } -pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathElems, +pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: DefPath, t: Ty<'tcx>, id: ast::NodeId) -> String { let mut hash = get_symbol_hash(ccx, t); @@ -353,14 +355,17 @@ pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathEl pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>, name: &str) -> String { - let path = [PathName(token::intern(&t.to_string())), - gensym_name(name)]; + let path = [token::intern(&t.to_string()).as_str(), gensym_name(name).as_str()]; let hash = get_symbol_hash(ccx, t); mangle(path.iter().cloned(), Some(&hash[..])) } -pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String { - mangle(path.chain(Some(gensym_name(flav))), None) +pub fn mangle_internal_name_by_path_and_seq(path: DefPath, flav: &str) -> String { + let names = + path.into_iter() + .map(|e| e.data.as_interned_str()) + .chain(once(gensym_name(flav).as_str())); // append unique version of "flav" + mangle(names, None) } pub fn get_linker(sess: &Session) -> (String, Command) { diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs index 769c124299899..f388f76c744e6 100644 --- a/src/librustc_trans/save/recorder.rs +++ b/src/librustc_trans/save/recorder.rs @@ -13,7 +13,8 @@ pub use self::Row::*; use super::escape; use super::span_utils::SpanUtils; -use middle::def_id::DefId; +use metadata::cstore::LOCAL_CRATE; +use middle::def_id::{CRATE_DEF_INDEX, DefId}; use std::io::Write; @@ -21,7 +22,7 @@ use syntax::ast; use syntax::ast::NodeId; use syntax::codemap::*; -const ZERO_DEF_ID: DefId = DefId { xxx_node: 0, krate: 0 }; +const CRATE_ROOT_DEF_ID: DefId = DefId { krate: LOCAL_CRATE, index: CRATE_DEF_INDEX }; pub struct Recorder { // output file @@ -381,7 +382,7 @@ impl<'a> FmtStrs<'a> { decl_id: Option, scope_id: NodeId) { let values = match decl_id { - Some(decl_id) => svec!(id, name, decl_id.xxx_node, decl_id.krate, scope_id), + Some(decl_id) => svec!(id, name, decl_id.index.as_usize(), decl_id.krate, scope_id), None => svec!(id, name, "", "", scope_id), }; self.check_and_record(Function, @@ -436,15 +437,15 @@ impl<'a> FmtStrs<'a> { ref_id: Option, trait_id: Option, scope_id: NodeId) { - let ref_id = ref_id.unwrap_or(ZERO_DEF_ID); - let trait_id = trait_id.unwrap_or(ZERO_DEF_ID); + let ref_id = ref_id.unwrap_or(CRATE_ROOT_DEF_ID); + let trait_id = trait_id.unwrap_or(CRATE_ROOT_DEF_ID); self.check_and_record(Impl, span, sub_span, svec!(id, - ref_id.xxx_node, + ref_id.index.as_usize(), ref_id.krate, - trait_id.xxx_node, + trait_id.index.as_usize(), trait_id.krate, scope_id)); } @@ -469,14 +470,11 @@ impl<'a> FmtStrs<'a> { mod_id: Option, name: &str, parent: NodeId) { - let (mod_node, mod_crate) = match mod_id { - Some(mod_id) => (mod_id.xxx_node, mod_id.krate), - None => (0, 0), - }; + let mod_id = mod_id.unwrap_or(CRATE_ROOT_DEF_ID); self.check_and_record(UseAlias, span, sub_span, - svec!(id, mod_node, mod_crate, name, parent)); + svec!(id, mod_id.index.as_usize(), mod_id.krate, name, parent)); } pub fn use_glob_str(&mut self, @@ -513,7 +511,7 @@ impl<'a> FmtStrs<'a> { self.check_and_record(Inheritance, span, sub_span, - svec!(base_id.xxx_node, + svec!(base_id.index.as_usize(), base_id.krate, deriv_id, 0)); @@ -527,7 +525,7 @@ impl<'a> FmtStrs<'a> { self.check_and_record(FnCall, span, sub_span, - svec!(id.xxx_node, id.krate, "", scope_id)); + svec!(id.index.as_usize(), id.krate, "", scope_id)); } pub fn meth_call_str(&mut self, @@ -536,18 +534,15 @@ impl<'a> FmtStrs<'a> { defid: Option, declid: Option, scope_id: NodeId) { - let (dfn, dfk) = match defid { - Some(defid) => (defid.xxx_node, defid.krate), - None => (0, 0), - }; + let defid = defid.unwrap_or(CRATE_ROOT_DEF_ID); let (dcn, dck) = match declid { - Some(declid) => (s!(declid.xxx_node), s!(declid.krate)), + Some(declid) => (s!(declid.index.as_usize()), s!(declid.krate)), None => ("".to_string(), "".to_string()), }; self.check_and_record(MethodCall, span, sub_span, - svec!(dfn, dfk, dcn, dck, scope_id)); + svec!(defid.index.as_usize(), defid.krate, dcn, dck, scope_id)); } pub fn sub_mod_ref_str(&mut self, span: Span, sub_span: Span, qualname: &str, parent: NodeId) { @@ -600,6 +595,6 @@ impl<'a> FmtStrs<'a> { self.check_and_record(kind, span, sub_span, - svec!(id.xxx_node, id.krate, "", scope_id)); + svec!(id.index.as_usize(), id.krate, "", scope_id)); } } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 61244e32c7d98..05b20ac3fb7d4 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -1576,7 +1576,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, param_substs); let has_env = match closure_env { - closure::ClosureEnv::Closure(_) => true, + closure::ClosureEnv::Closure(..) => true, closure::ClosureEnv::NotClosure => false, }; @@ -2309,10 +2309,11 @@ fn exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, id: ast::NodeId, match attr::find_export_name_attr(ccx.sess().diagnostic(), attrs) { // Use provided name Some(name) => name.to_string(), - _ => ccx.tcx().map.with_path(id, |path| { + _ => { + let path = ccx.tcx().map.def_path_from_id(id); if attr::contains_name(attrs, "no_mangle") { // Don't mangle - path.last().unwrap().to_string() + path.last().unwrap().data.to_string() } else { match weak_lang_items::link_name(attrs) { Some(name) => name.to_string(), @@ -2322,7 +2323,7 @@ fn exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, id: ast::NodeId, } } } - }) + } } } diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index 89724c38cb2c9..d3509c2f8133a 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -36,6 +36,7 @@ use rustc_front::hir; fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, + closure_def_id: DefId, arg_scope_id: ScopeId, freevars: &[ty::Freevar]) -> Block<'blk, 'tcx> @@ -43,9 +44,9 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("closure::load_closure_environment"); // Special case for small by-value selfs. - let closure_id = bcx.tcx().map.local_def_id(bcx.fcx.id); - let self_type = self_type_for_closure(bcx.ccx(), closure_id, node_id_type(bcx, bcx.fcx.id)); - let kind = kind_for_closure(bcx.ccx(), closure_id); + let closure_ty = node_id_type(bcx, bcx.fcx.id); + let self_type = self_type_for_closure(bcx.ccx(), closure_def_id, closure_ty); + let kind = kind_for_closure(bcx.ccx(), closure_def_id); let llenv = if kind == ty::FnOnceClosureKind && !arg_is_indirect(bcx.ccx(), self_type) { let datum = rvalue_scratch_datum(bcx, @@ -106,7 +107,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pub enum ClosureEnv<'a> { NotClosure, - Closure(&'a [ty::Freevar]), + Closure(DefId, &'a [ty::Freevar]), } impl<'a> ClosureEnv<'a> { @@ -115,11 +116,11 @@ impl<'a> ClosureEnv<'a> { { match self { ClosureEnv::NotClosure => bcx, - ClosureEnv::Closure(freevars) => { + ClosureEnv::Closure(def_id, freevars) => { if freevars.is_empty() { bcx } else { - load_closure_environment(bcx, arg_scope, freevars) + load_closure_environment(bcx, def_id, arg_scope, freevars) } } } @@ -132,8 +133,6 @@ pub fn get_or_create_closure_declaration<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, closure_id: DefId, substs: &ty::ClosureSubsts<'tcx>) -> ValueRef { - let closure_node_id = ccx.tcx().map.as_local_node_id(closure_id).unwrap(); - // Normalize type so differences in regions and typedefs don't cause // duplicate declarations let substs = ccx.tcx().erase_regions(substs); @@ -148,9 +147,8 @@ pub fn get_or_create_closure_declaration<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, return llfn; } - let symbol = ccx.tcx().map.with_path(closure_node_id, |path| { - mangle_internal_name_by_path_and_seq(path, "closure") - }); + let path = ccx.tcx().def_path(closure_id); + let symbol = mangle_internal_name_by_path_and_seq(path, "closure"); let function_type = ccx.tcx().mk_closure_from_closure_substs(closure_id, Box::new(substs)); let llfn = declare::define_internal_rust_fn(ccx, &symbol[..], function_type); @@ -177,9 +175,14 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, decl: &hir::FnDecl, body: &hir::Block, id: ast::NodeId, + closure_def_id: DefId, // (*) closure_substs: &'tcx ty::ClosureSubsts<'tcx>) -> Option> { + // (*) Note that in the case of inlined functions, the `closure_def_id` will be the + // defid of the closure in its original crate, whereas `id` will be the id of the local + // inlined copy. + let param_substs = closure_substs.func_substs; let ccx = match dest { @@ -189,10 +192,10 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, let tcx = ccx.tcx(); let _icx = push_ctxt("closure::trans_closure_expr"); - debug!("trans_closure_expr()"); + debug!("trans_closure_expr(id={:?}, closure_def_id={:?}, closure_substs={:?})", + id, closure_def_id, closure_substs); - let closure_id = tcx.map.local_def_id(id); - let llfn = get_or_create_closure_declaration(ccx, closure_id, closure_substs); + let llfn = get_or_create_closure_declaration(ccx, closure_def_id, closure_substs); // Get the type of this closure. Use the current `param_substs` as // the closure substitutions. This makes sense because the closure @@ -201,7 +204,7 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, // of the closure expression. let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables); - let function_type = infcx.closure_type(closure_id, closure_substs); + let function_type = infcx.closure_type(closure_def_id, closure_substs); let freevars: Vec = tcx.with_freevars(id, |fv| fv.iter().cloned().collect()); @@ -217,7 +220,7 @@ pub fn trans_closure_expr<'a, 'tcx>(dest: Dest<'a, 'tcx>, &[], sig.output, function_type.abi, - ClosureEnv::Closure(&freevars)); + ClosureEnv::Closure(closure_def_id, &freevars)); // Don't hoist this to the top of the function. It's perfectly legitimate // to have a zero-size closure (in which case dest will be `Ignore`) and diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index ba50bec2ecd91..d160465c619b9 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -39,7 +39,6 @@ use trans::type_of; use middle::traits; use middle::ty::{self, HasTypeFlags, Ty}; use middle::ty::fold::{TypeFolder, TypeFoldable}; -use rustc::front::map::{PathElem, PathName}; use rustc_front::hir; use util::nodemap::{FnvHashMap, NodeMap}; @@ -167,11 +166,11 @@ pub fn return_type_is_void(ccx: &CrateContext, ty: Ty) -> bool { /// Generates a unique symbol based off the name given. This is used to create /// unique symbols for things like closures. -pub fn gensym_name(name: &str) -> PathElem { +pub fn gensym_name(name: &str) -> ast::Name { let num = token::gensym(name).0; // use one colon which will get translated to a period by the mangler, and // we're guaranteed that `num` is globally unique for this crate. - PathName(token::gensym(&format!("{}:{}", name, num))) + token::gensym(&format!("{}:{}", name, num)) } /* @@ -1020,7 +1019,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, trait_ref); ccx.sess().span_fatal( span, - "reached the recursion limit during monomorphization"); + "reached the recursion limit during monomorphization (selection ambiguity)"); } Err(e) => { tcx.sess.span_bug( diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 6aa087cce56bd..a7bb4043e7d81 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -877,9 +877,9 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }, hir::ExprClosure(_, ref decl, ref body) => { match ety.sty { - ty::TyClosure(_, ref substs) => { + ty::TyClosure(def_id, ref substs) => { closure::trans_closure_expr(closure::Dest::Ignore(cx), decl, - body, e.id, substs); + body, e.id, def_id, substs); } _ => cx.sess().span_bug( diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 94c93a636a12c..a921bbbc43e30 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -346,7 +346,7 @@ impl<'tcx> TypeMap<'tcx> { output.push_str(crate_hash.as_str()); output.push_str("/"); - output.push_str(&format!("{:x}", def_id.xxx_node)); + output.push_str(&format!("{:x}", def_id.index.as_usize())); // Maybe check that there is no self type here. diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 476e05d50d20f..8d57c24ca90bb 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -1195,14 +1195,23 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, SaveIn(lldest) => closure::Dest::SaveIn(bcx, lldest), Ignore => closure::Dest::Ignore(bcx.ccx()) }; - let substs = match expr_ty(bcx, expr).sty { - ty::TyClosure(_, ref substs) => substs, + + // NB. To get the id of the closure, we don't use + // `local_def_id(id)`, but rather we extract the closure + // def-id from the expr's type. This is because this may + // be an inlined expression from another crate, and we + // want to get the ORIGINAL closure def-id, since that is + // the key we need to find the closure-kind and + // closure-type etc. + let (def_id, substs) = match expr_ty(bcx, expr).sty { + ty::TyClosure(def_id, ref substs) => (def_id, substs), ref t => bcx.tcx().sess.span_bug( expr.span, &format!("closure expr without closure type: {:?}", t)), }; - closure::trans_closure_expr(dest, decl, body, expr.id, substs).unwrap_or(bcx) + + closure::trans_closure_expr(dest, decl, body, expr.id, def_id, substs).unwrap_or(bcx) } hir::ExprCall(ref f, ref args) => { if bcx.tcx().is_method_call(expr.id) { diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 0310a8a604106..6b9f1559d3793 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -29,9 +29,9 @@ use trans::type_of::*; use trans::type_of; use middle::ty::{self, Ty}; use middle::subst::Substs; -use rustc::front::map as hir_map; use std::cmp; +use std::iter::once; use libc::c_uint; use syntax::abi::{Cdecl, Aapcs, C, Win64, Abi}; use syntax::abi::{PlatformIntrinsic, RustIntrinsic, Rust, RustCall, Stdcall, Fastcall, System}; @@ -610,10 +610,12 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let t = tcx.node_id_to_type(id); let t = monomorphize::apply_param_substs(tcx, param_substs, &t); - let ps = ccx.tcx().map.with_path(id, |path| { - let abi = Some(hir_map::PathName(special_idents::clownshoe_abi.name)); - link::mangle(path.chain(abi), hash) - }); + let path = + tcx.map.def_path_from_id(id) + .into_iter() + .map(|e| e.data.as_interned_str()) + .chain(once(special_idents::clownshoe_abi.name.as_str())); + let ps = link::mangle(path, hash); // Compute the type that the function would have if it were just a // normal Rust function. This will be the type of the wrappee fn. diff --git a/src/librustc_trans/trans/inline.rs b/src/librustc_trans/trans/inline.rs index 67abca78c6eb3..14b65bcb75504 100644 --- a/src/librustc_trans/trans/inline.rs +++ b/src/librustc_trans/trans/inline.rs @@ -44,7 +44,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) let csearch_result = csearch::maybe_get_item_ast( ccx.tcx(), fn_id, - Box::new(|a,b,c,d| astencode::decode_inlined_item(a, b, c, d))); + Box::new(|a,b,c,d,e| astencode::decode_inlined_item(a, b, c, d,e))); let inline_id = match csearch_result { csearch::FoundAst::NotFound => { diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs index 39f3a29c785f4..33f798be85e87 100644 --- a/src/librustc_trans/trans/monomorphize.rs +++ b/src/librustc_trans/trans/monomorphize.rs @@ -110,6 +110,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, Some(&d) => d, None => 0 }; + debug!("monomorphic_fn: depth for fn_id={:?} is {:?}", fn_id, depth+1); + // Random cut-off -- code that needs to instantiate the same function // recursively more than thirty times can probably safely be assumed // to be causing an infinite expansion. @@ -128,9 +130,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, mono_ty.hash(&mut state); hash = format!("h{}", state.finish()); - ccx.tcx().map.with_path(fn_node_id, |path| { - exported_name(path, &hash[..]) - }) + let path = ccx.tcx().map.def_path_from_id(fn_node_id); + exported_name(path, &hash[..]) }; debug!("monomorphize_fn mangled to {}", s); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index dab4056b4af81..3492635a20be4 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -39,7 +39,7 @@ use rustc::metadata::cstore; use rustc::metadata::csearch; use rustc::metadata::decoder; use rustc::middle::def; -use rustc::middle::def_id::DefId; +use rustc::middle::def_id::{DefId, DefIndex}; use rustc::middle::subst::{self, ParamSpace, VecPerParamSpace}; use rustc::middle::ty; use rustc::middle::stability; @@ -188,7 +188,7 @@ impl<'a, 'tcx> Clean for visit_ast::RustdocVisitor<'a, 'tcx> { attrs: child.attrs.clone(), visibility: Some(hir::Public), stability: None, - def_id: DefId::xxx_local(prim.to_node_id()), + def_id: DefId::local(prim.to_def_index()), inner: PrimitiveItem(prim), }); } @@ -1559,8 +1559,9 @@ impl PrimitiveType { /// Creates a rustdoc-specific node id for primitive types. /// /// These node ids are generally never used by the AST itself. - pub fn to_node_id(&self) -> ast::NodeId { - u32::MAX - 1 - (*self as u32) + pub fn to_def_index(&self) -> DefIndex { + let x = u32::MAX - 1 - (*self as u32); + DefIndex::new(x as usize) } } @@ -1744,7 +1745,7 @@ impl<'tcx> Clean for ty::FieldDefData<'tcx, 'static> { let (name, attrs) = if self.name == unnamed_field.name { (None, None) } else { - (Some(self.name), Some(attr_map.get(&self.did.xxx_node).unwrap())) + (Some(self.name), Some(attr_map.get(&self.did).unwrap())) }; Item { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 6937dbf255e2e..d12c5d2c6fb6b 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -19,9 +19,8 @@ use std::fmt; use std::iter::repeat; use rustc::metadata::cstore::LOCAL_CRATE; -use rustc::middle::def_id::DefId; +use rustc::middle::def_id::{CRATE_DEF_INDEX, DefId}; use syntax::abi::Abi; -use syntax::ast; use rustc_front::hir; use clean; @@ -387,7 +386,7 @@ fn primitive_link(f: &mut fmt::Formatter, Some(&cnum) => { let path = &m.paths[&DefId { krate: cnum, - xxx_node: ast::CRATE_NODE_ID, + index: CRATE_DEF_INDEX, }]; let loc = match m.extern_locations[&cnum] { (_, render::Remote(ref s)) => Some(s.to_string()), diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 708c8f634f553..cf03482e18b8a 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -54,7 +54,7 @@ use externalfiles::ExternalHtml; use serialize::json::{self, ToJson}; use syntax::{abi, ast, attr}; use rustc::metadata::cstore::LOCAL_CRATE; -use rustc::middle::def_id::DefId; +use rustc::middle::def_id::{CRATE_DEF_INDEX, DefId}; use rustc::util::nodemap::DefIdSet; use rustc_front::hir; @@ -413,7 +413,7 @@ pub fn run(mut krate: clean::Crate, for &(n, ref e) in &krate.externs { cache.extern_locations.insert(n, (e.name.clone(), extern_location(e, &cx.dst))); - let did = DefId { krate: n, xxx_node: ast::CRATE_NODE_ID }; + let did = DefId { krate: n, index: CRATE_DEF_INDEX }; cache.paths.insert(did, (vec![e.name.to_string()], ItemType::Module)); } @@ -1034,7 +1034,7 @@ impl DocFolder for Cache { ref t => { match t.primitive_type() { Some(prim) => { - let did = DefId::xxx_local(prim.to_node_id()); // TODO + let did = DefId::local(prim.to_def_index()); self.parent_stack.push(did); true } @@ -1079,8 +1079,8 @@ impl DocFolder for Cache { ref t => { t.primitive_type().and_then(|t| { self.primitive_locations.get(&t).map(|n| { - let id = t.to_node_id(); - DefId { krate: *n, xxx_node: id } + let id = t.to_def_index(); + DefId { krate: *n, index: id } }) }) } @@ -1421,7 +1421,7 @@ impl<'a> Item<'a> { root = root, path = path[..path.len() - 1].join("/"), file = item_path(self.item), - goto = self.item.def_id.xxx_node)) + goto = self.item.def_id.index.as_usize())) } } } @@ -1481,7 +1481,7 @@ impl<'a> fmt::Display for Item<'a> { Some(l) => { try!(write!(fmt, "[src]", - self.item.def_id.xxx_node, l, "goto source code")); + self.item.def_id.index.as_usize(), l, "goto source code")); } None => {} } @@ -2337,7 +2337,7 @@ fn render_deref_methods(w: &mut fmt::Formatter, cx: &Context, impl_: &Impl) -> f _ => { if let Some(prim) = target.primitive_type() { if let Some(c) = cache().primitive_locations.get(&prim) { - let did = DefId { krate: *c, xxx_node: prim.to_node_id() }; + let did = DefId { krate: *c, index: prim.to_def_index() }; try!(render_assoc_items(w, cx, did, what)); } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 45e1d00586327..d186918f44aaa 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -167,13 +167,13 @@ impl fmt::Display for Ident { impl Encodable for Ident { fn encode(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_str(&self.name.as_str()) + self.name.encode(s) } } impl Decodable for Ident { fn decode(d: &mut D) -> Result { - Ok(str_to_ident(&try!(d.read_str())[..])) + Ok(Ident::with_empty_ctxt(try!(Name::decode(d)))) } } From 52a02832b8d97226eae9f3baac671dc5b562d332 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 30 Sep 2015 08:33:22 -0400 Subject: [PATCH 15/17] convert the creepy case to just return None -- in practice, it would have always been returning None anyway, since it was comparing node-ids across crates incorrectly -- and remove the now unused map `extern_const_variants` --- src/librustc/middle/const_eval.rs | 27 +-------------------------- src/librustc/middle/ty/context.rs | 2 -- 2 files changed, 1 insertion(+), 28 deletions(-) diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 91d9f70aee9a7..2d74525e4edfc 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -82,32 +82,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, Some(_) => None } } else { - match tcx.extern_const_variants.borrow().get(&variant_def) { - Some(&ast::DUMMY_NODE_ID) => return None, - Some(&expr_id) => { - return Some(tcx.map.expect_expr(expr_id)); - } - None => {} - } - let expr_id = match - csearch::maybe_get_item_ast( - tcx, enum_def, - Box::new(|a, b, c, d, e| astencode::decode_inlined_item(a, b, c, d, e))) - { - csearch::FoundAst::Found(&InlinedItem::Item(ref item)) => match item.node { - hir::ItemEnum(hir::EnumDef { .. }, _) => { - tcx.sess.span_bug( - item.span, - &format!("cross-crate enum discr constant with enum {:?} variant {:?}", - enum_def, variant_def)); - } - _ => None - }, - _ => None - }; - tcx.extern_const_variants.borrow_mut().insert(variant_def, - expr_id.unwrap_or(ast::DUMMY_NODE_ID)); - expr_id.map(|id| tcx.map.expect_expr(id)) + None } } diff --git a/src/librustc/middle/ty/context.rs b/src/librustc/middle/ty/context.rs index 906ff5b2656e7..e506e5b2c0772 100644 --- a/src/librustc/middle/ty/context.rs +++ b/src/librustc/middle/ty/context.rs @@ -307,7 +307,6 @@ pub struct ctxt<'tcx> { /// These caches are used by const_eval when decoding external constants. pub extern_const_statics: RefCell>, - pub extern_const_variants: RefCell>, pub extern_const_fns: RefCell>, pub node_lint_levels: RefCell ctxt<'tcx> { populated_external_types: RefCell::new(DefIdSet()), populated_external_primitive_impls: RefCell::new(DefIdSet()), extern_const_statics: RefCell::new(DefIdMap()), - extern_const_variants: RefCell::new(DefIdMap()), extern_const_fns: RefCell::new(DefIdMap()), node_lint_levels: RefCell::new(FnvHashMap()), transmute_restrictions: RefCell::new(Vec::new()), From 6bfdf37250155afa872f7cbbde745e0b050e4f3a Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 30 Sep 2015 16:53:14 -0400 Subject: [PATCH 16/17] remove code for re-exports of static methods --- src/librustc/metadata/encoder.rs | 122 +------------------------------ 1 file changed, 3 insertions(+), 119 deletions(-) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index f637545e2e910..1511ea2bc07db 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -366,120 +366,6 @@ fn encode_path>(rbml_w: &mut Encoder, path: PI) { rbml_w.end_tag(); } -fn encode_reexported_static_method(rbml_w: &mut Encoder, - exp: &def::Export, - method_def_id: DefId, - method_name: Name) { - debug!("(encode reexported static method) {}::{}", - exp.name, method_name); - rbml_w.start_tag(tag_items_data_item_reexport); - rbml_w.wr_tagged_u64(tag_items_data_item_reexport_def_id, - def_to_u64(method_def_id)); - rbml_w.wr_tagged_str(tag_items_data_item_reexport_name, - &format!("{}::{}", exp.name, - method_name)); - rbml_w.end_tag(); -} - -fn encode_reexported_static_base_methods(ecx: &EncodeContext, - rbml_w: &mut Encoder, - exp: &def::Export) - -> bool { - let impl_items = ecx.tcx.impl_items.borrow(); - match ecx.tcx.inherent_impls.borrow().get(&exp.def_id) { - Some(implementations) => { - for base_impl_did in implementations.iter() { - for &method_did in impl_items.get(base_impl_did).unwrap() { - let impl_item = ecx.tcx.impl_or_trait_item(method_did.def_id()); - if let ty::MethodTraitItem(ref m) = impl_item { - encode_reexported_static_method(rbml_w, - exp, - m.def_id, - m.name); - } - } - } - - true - } - None => { false } - } -} - -fn encode_reexported_static_trait_methods(ecx: &EncodeContext, - rbml_w: &mut Encoder, - exp: &def::Export) - -> bool { - match ecx.tcx.trait_items_cache.borrow().get(&exp.def_id) { - Some(trait_items) => { - for trait_item in trait_items.iter() { - if let ty::MethodTraitItem(ref m) = *trait_item { - encode_reexported_static_method(rbml_w, - exp, - m.def_id, - m.name); - } - } - true - } - None => { false } - } -} - -fn encode_reexported_static_methods(ecx: &EncodeContext, - rbml_w: &mut Encoder, - mod_path: PathElems, - exp: &def::Export) { - let exp_node_id = if let Some(n) = ecx.tcx.map.as_local_node_id(exp.def_id) { - n - } else { - // Before the refactor that introducd `as_local_node_id`, we - // were just extracting the node and checking into the - // ast-map. Since the node might have been from another crate, - // this was a tenuous thing to do at best. Anyway, I'm not - // 100% clear on why it's ok to ignore things from other - // crates, but it seems to be what we were doing pre-refactor. - // -nmatsakis - return; - }; - - if let Some(ast_map::NodeItem(item)) = ecx.tcx.map.find(exp_node_id) { - let path_differs = ecx.tcx.map.with_path(exp_node_id, |path| { - let (mut a, mut b) = (path, mod_path.clone()); - loop { - match (a.next(), b.next()) { - (None, None) => return true, - (None, _) | (_, None) => return false, - (Some(x), Some(y)) => if x != y { return false }, - } - } - }); - - // - // We don't need to reexport static methods on items - // declared in the same module as our `pub use ...` since - // that's done when we encode the item itself. - // - // The only exception is when the reexport *changes* the - // name e.g. `pub use Foo = self::Bar` -- we have - // encoded metadata for static methods relative to Bar, - // but not yet for Foo. - // - if path_differs || item.name != exp.name { - if !encode_reexported_static_base_methods(ecx, rbml_w, exp) { - if encode_reexported_static_trait_methods(ecx, rbml_w, exp) { - debug!("(encode reexported static methods) {} [trait]", - item.name); - } - } - else { - debug!("(encode reexported static methods) {} [base]", - item.name); - } - } - } -} - /// Iterates through "auxiliary node IDs", which are node IDs that describe /// top-level items that are sub-items of the given item. Specifically: /// @@ -507,8 +393,7 @@ fn each_auxiliary_node_id(item: &hir::Item, callback: F) -> bool where fn encode_reexports(ecx: &EncodeContext, rbml_w: &mut Encoder, - id: NodeId, - path: PathElems) { + id: NodeId) { debug!("(encoding info for module) encoding reexports for {}", id); match ecx.reexports.get(&id) { Some(exports) => { @@ -525,7 +410,6 @@ fn encode_reexports(ecx: &EncodeContext, rbml_w.wr_tagged_str(tag_items_data_item_reexport_name, &exp.name.as_str()); rbml_w.end_tag(); - encode_reexported_static_methods(ecx, rbml_w, path.clone(), exp); } }, None => debug!("(encoding info for module) found no reexports for {}", id), @@ -576,7 +460,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, // Encode the reexports of this module, if this module is public. if vis == hir::Public { debug!("(encoding info for module) encoding reexports for {}", id); - encode_reexports(ecx, rbml_w, id, path); + encode_reexports(ecx, rbml_w, id); } encode_attributes(rbml_w, attrs); @@ -1930,7 +1814,7 @@ fn encode_misc_info(ecx: &EncodeContext, } // Encode reexports for the root module. - encode_reexports(ecx, rbml_w, 0, [].iter().cloned().chain(LinkedPath::empty())); + encode_reexports(ecx, rbml_w, 0); rbml_w.end_tag(); rbml_w.end_tag(); From f0dc7bd1fdc8eb951a1c9d15b05868f47d412553 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 1 Oct 2015 11:10:30 -0400 Subject: [PATCH 17/17] remove support method for synthetic default method ids --- src/librustc/front/map/mod.rs | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs index aba6429abaefd..825d5da0c999d 100644 --- a/src/librustc/front/map/mod.rs +++ b/src/librustc/front/map/mod.rs @@ -305,22 +305,6 @@ impl<'ast> Map<'ast> { self.definitions.borrow().as_local_node_id(def_id) } - /// for default methods, we create a fake node-id; this method - /// adds that fake node-id to the def-id tables - pub fn synthesize_default_method_def_id(&self, - impl_def_id: DefId, - new_method_id: NodeId, - method_name: Name) - -> DefId { - assert!(impl_def_id.is_local()); - let index = - self.definitions.borrow_mut() - .create_def_with_parent(Some(impl_def_id.index), - new_method_id, - DefPathData::Value(method_name)); - DefId::local(index) - } - fn entry_count(&self) -> usize { self.map.borrow().len() }