user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

HirIdification: replace NodeId method calls

Browse source
This commit is contained in:
ljedrz 2019-03-04 09:00:30 +01:00
parent 88f755f8a8
commit cd06038b54
69 changed files with 336 additions and 339 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/librustc/hir/map/mod.rs
View file

@ -501,10 +501,10 @@ impl<'hir> Map<'hir> {
}
/// Given a body owner's id, returns the `BodyId` associated with it.
pub fn body_owned_by(&self, id: NodeId) -> BodyId {
self.maybe_body_owned_by(id).unwrap_or_else(|| {
span_bug!(self.span(id), "body_owned_by: {} has no associated body",
self.node_to_string(id));
pub fn body_owned_by(&self, id: HirId) -> BodyId {
self.maybe_body_owned_by_by_hir_id(id).unwrap_or_else(|| {
span_bug!(self.span_by_hir_id(id), "body_owned_by: {} has no associated body",
self.hir_to_string(id));
})
}
@ -539,19 +539,19 @@ impl<'hir> Map<'hir> {
self.body_owner_kind(node_id)
}
pub fn ty_param_owner(&self, id: NodeId) -> NodeId {
match self.get(id) {
pub fn ty_param_owner(&self, id: HirId) -> HirId {
match self.get_by_hir_id(id) {
Node::Item(&Item { node: ItemKind::Trait(..), .. }) => id,
Node::GenericParam(_) => self.get_parent_node(id),
_ => bug!("ty_param_owner: {} not a type parameter", self.node_to_string(id))
Node::GenericParam(_) => self.get_parent_node_by_hir_id(id),
_ => bug!("ty_param_owner: {} not a type parameter", self.hir_to_string(id))
}
}
pub fn ty_param_name(&self, id: NodeId) -> Name {
match self.get(id) {
pub fn ty_param_name(&self, id: HirId) -> Name {
match self.get_by_hir_id(id) {
Node::Item(&Item { node: ItemKind::Trait(..), .. }) => keywords::SelfUpper.name(),
Node::GenericParam(param) => param.name.ident().name,
_ => bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)),
_ => bug!("ty_param_name: {} not a type parameter", self.hir_to_string(id)),
}
}

30
src/librustc/infer/opaque_types/mod.rs
View file

@ -4,7 +4,6 @@ use crate::hir::Node;
use crate::infer::{self, InferCtxt, InferOk, TypeVariableOrigin};
use crate::infer::outlives::free_region_map::FreeRegionRelations;
use rustc_data_structures::fx::FxHashMap;
use syntax::ast;
use crate::traits::{self, PredicateObligation};
use crate::ty::{self, Ty, TyCtxt, GenericParamDefKind};
use crate::ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder};
@ -686,13 +685,14 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
// let x = || foo(); // returns the Opaque assoc with `foo`
// }
// ```
if let Some(opaque_node_id) = tcx.hir().as_local_node_id(def_id) {
if let Some(opaque_hir_id) = tcx.hir().as_local_hir_id(def_id) {
let parent_def_id = self.parent_def_id;
let def_scope_default = || {
let opaque_parent_node_id = tcx.hir().get_parent(opaque_node_id);
parent_def_id == tcx.hir().local_def_id(opaque_parent_node_id)
let opaque_parent_hir_id = tcx.hir().get_parent_item(opaque_hir_id);
parent_def_id == tcx.hir()
.local_def_id_from_hir_id(opaque_parent_hir_id)
};
let in_definition_scope = match tcx.hir().find(opaque_node_id) {
let in_definition_scope = match tcx.hir().find_by_hir_id(opaque_hir_id) {
Some(Node::Item(item)) => match item.node {
// impl trait
hir::ItemKind::Existential(hir::ExistTy {
@ -706,7 +706,7 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
}) => may_define_existential_type(
tcx,
self.parent_def_id,
opaque_node_id,
opaque_hir_id,
),
_ => def_scope_default(),
},
@ -714,13 +714,13 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
hir::ImplItemKind::Existential(_) => may_define_existential_type(
tcx,
self.parent_def_id,
opaque_node_id,
opaque_hir_id,
),
_ => def_scope_default(),
},
_ => bug!(
"expected (impl) item, found {}",
tcx.hir().node_to_string(opaque_node_id),
tcx.hir().hir_to_string(opaque_hir_id),
),
};
if in_definition_scope {
@ -839,20 +839,20 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
pub fn may_define_existential_type(
tcx: TyCtxt<'_, '_, '_>,
def_id: DefId,
opaque_node_id: ast::NodeId,
opaque_hir_id: hir::HirId,
) -> bool {
let mut node_id = tcx
let mut hir_id = tcx
.hir()
.as_local_node_id(def_id)
.as_local_hir_id(def_id)
.unwrap();
// named existential types can be defined by any siblings or
// children of siblings
let mod_id = tcx.hir().get_parent(opaque_node_id);
let mod_id = tcx.hir().get_parent_item(opaque_hir_id);
// so we walk up the node tree until we hit the root or the parent
// of the opaque type
while node_id != mod_id && node_id != ast::CRATE_NODE_ID {
node_id = tcx.hir().get_parent(node_id);
while hir_id != mod_id && hir_id != hir::CRATE_HIR_ID {
hir_id = tcx.hir().get_parent_item(hir_id);
}
// syntactically we are allowed to define the concrete type
node_id == mod_id
hir_id == mod_id
}

5
src/librustc/middle/expr_use_visitor.rs
View file

@ -918,9 +918,8 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
fn walk_captures(&mut self, closure_expr: &hir::Expr, fn_decl_span: Span) {
debug!("walk_captures({:?})", closure_expr);
let closure_node_id = self.tcx().hir().hir_to_node_id(closure_expr.hir_id);
let closure_def_id = self.tcx().hir().local_def_id(closure_node_id);
self.tcx().with_freevars(closure_node_id, |freevars| {
let closure_def_id = self.tcx().hir().local_def_id_from_hir_id(closure_expr.hir_id);
self.tcx().with_freevars(closure_expr.hir_id, |freevars| {
for freevar in freevars {
let var_hir_id = self.tcx().hir().node_to_hir_id(freevar.var_id());
let upvar_id = ty::UpvarId {

3
src/librustc/middle/liveness.rs
View file

@ -476,8 +476,7 @@ fn visit_expr<'a, 'tcx>(ir: &mut IrMaps<'a, 'tcx>, expr: &'tcx Expr) {
// in better error messages than just pointing at the closure
// construction site.
let mut call_caps = Vec::new();
let node_id = ir.tcx.hir().hir_to_node_id(expr.hir_id);
ir.tcx.with_freevars(node_id, |freevars| {
ir.tcx.with_freevars(expr.hir_id, |freevars| {
call_caps.extend(freevars.iter().filter_map(|fv| {
if let Def::Local(rv) = fv.def {
let fv_ln = ir.add_live_node(FreeVarNode(fv.span));

12
src/librustc/middle/reachable.rs
View file

@ -51,8 +51,8 @@ fn method_might_be_inlined<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
if codegen_fn_attrs.requests_inline() || generics.requires_monomorphization(tcx) {
return true
}
if let Some(impl_node_id) = tcx.hir().as_local_node_id(impl_src) {
match tcx.hir().find(impl_node_id) {
if let Some(impl_hir_id) = tcx.hir().as_local_hir_id(impl_src) {
match tcx.hir().find_by_hir_id(impl_hir_id) {
Some(Node::Item(item)) =>
item_might_be_inlined(tcx, &item, codegen_fn_attrs),
Some(..) | None =>
@ -141,12 +141,12 @@ 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 {
let node_id = match self.tcx.hir().as_local_node_id(def_id) {
Some(node_id) => node_id,
let hir_id = match self.tcx.hir().as_local_hir_id(def_id) {
Some(hir_id) => hir_id,
None => { return false; }
};
match self.tcx.hir().find(node_id) {
match self.tcx.hir().find_by_hir_id(hir_id) {
Some(Node::Item(item)) => {
match item.node {
hir::ItemKind::Fn(..) =>
@ -173,7 +173,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
} else {
let impl_did = self.tcx
.hir()
.get_parent_did(node_id);
.get_parent_did_by_hir_id(hir_id);
// Check the impl. If the generics on the self
// type of the impl require inlining, this method
// does too.

18
src/librustc/middle/region.rs
View file

@ -223,7 +223,7 @@ pub struct ScopeTree {
/// The parent of the root body owner, if the latter is an
/// an associated const or method, as impls/traits can also
/// have lifetime parameters free in this body.
root_parent: Option<ast::NodeId>,
root_parent: Option<hir::HirId>,
/// `parent_map` maps from a scope ID to the enclosing scope id;
/// this is usually corresponding to the lexical nesting, though
@ -650,8 +650,8 @@ impl<'tcx> ScopeTree {
-> Scope {
let param_owner = tcx.parent_def_id(br.def_id).unwrap();
let param_owner_id = tcx.hir().as_local_node_id(param_owner).unwrap();
let scope = tcx.hir().maybe_body_owned_by(param_owner_id).map(|body_id| {
let param_owner_id = tcx.hir().as_local_hir_id(param_owner).unwrap();
let scope = tcx.hir().maybe_body_owned_by_by_hir_id(param_owner_id).map(|body_id| {
tcx.hir().body(body_id).value.hir_id.local_id
}).unwrap_or_else(|| {
// The lifetime was defined on node that doesn't own a body,
@ -661,7 +661,7 @@ impl<'tcx> ScopeTree {
"free_scope: {:?} not recognized by the \
region scope tree for {:?} / {:?}",
param_owner,
self.root_parent.map(|id| tcx.hir().local_def_id(id)),
self.root_parent.map(|id| tcx.hir().local_def_id_from_hir_id(id)),
self.root_body.map(|hir_id| DefId::local(hir_id.owner)));
// The trait/impl lifetime is in scope for the method's body.
@ -686,7 +686,7 @@ impl<'tcx> ScopeTree {
// on the same function that they ended up being freed in.
assert_eq!(param_owner, fr.scope);
let param_owner_id = tcx.hir().as_local_node_id(param_owner).unwrap();
let param_owner_id = tcx.hir().as_local_hir_id(param_owner).unwrap();
let body_id = tcx.hir().body_owned_by(param_owner_id);
Scope { id: tcx.hir().body(body_id).value.hir_id.local_id, data: ScopeData::CallSite }
}
@ -1328,8 +1328,8 @@ fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
return tcx.region_scope_tree(closure_base_def_id);
}
let id = tcx.hir().as_local_node_id(def_id).unwrap();
let scope_tree = if let Some(body_id) = tcx.hir().maybe_body_owned_by(id) {
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let scope_tree = if let Some(body_id) = tcx.hir().maybe_body_owned_by_by_hir_id(id) {
let mut visitor = RegionResolutionVisitor {
tcx,
scope_tree: ScopeTree::default(),
@ -1348,10 +1348,10 @@ fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
// If the item is an associated const or a method,
// record its impl/trait parent, as it can also have
// lifetime parameters free in this body.
match tcx.hir().get(id) {
match tcx.hir().get_by_hir_id(id) {
Node::ImplItem(_) |
Node::TraitItem(_) => {
visitor.scope_tree.root_parent = Some(tcx.hir().get_parent(id));
visitor.scope_tree.root_parent = Some(tcx.hir().get_parent_item(id));
}
_ => {}
}

10
src/librustc/middle/resolve_lifetime.rs
View file

@ -1585,9 +1585,9 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
match lifetimeuseset {
Some(LifetimeUseSet::One(lifetime)) => {
let node_id = self.tcx.hir().as_local_node_id(def_id).unwrap();
debug!("node id first={:?}", node_id);
if let Some((id, span, name)) = match self.tcx.hir().get(node_id) {
let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
debug!("hir id first={:?}", hir_id);
if let Some((id, span, name)) = match self.tcx.hir().get_by_hir_id(hir_id) {
Node::Lifetime(hir_lifetime) => Some((
hir_lifetime.hir_id,
hir_lifetime.span,
@ -1626,8 +1626,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
debug!("Not one use lifetime");
}
None => {
let node_id = self.tcx.hir().as_local_node_id(def_id).unwrap();
if let Some((id, span, name)) = match self.tcx.hir().get(node_id) {
let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
if let Some((id, span, name)) = match self.tcx.hir().get_by_hir_id(hir_id) {
Node::Lifetime(hir_lifetime) => Some((
hir_lifetime.hir_id,
hir_lifetime.span,

15
src/librustc/mir/mod.rs
View file

@ -2411,15 +2411,15 @@ impl<'tcx> Debug for Rvalue<'tcx> {
}
AggregateKind::Closure(def_id, _) => ty::tls::with(|tcx| {
if let Some(node_id) = tcx.hir().as_local_node_id(def_id) {
if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
let name = if tcx.sess.opts.debugging_opts.span_free_formats {
format!("[closure@{:?}]", node_id)
format!("[closure@{:?}]", hir_id)
} else {
format!("[closure@{:?}]", tcx.hir().span(node_id))
format!("[closure@{:?}]", tcx.hir().span_by_hir_id(hir_id))
};
let mut struct_fmt = fmt.debug_struct(&name);
tcx.with_freevars(node_id, |freevars| {
tcx.with_freevars(hir_id, |freevars| {
for (freevar, place) in freevars.iter().zip(places) {
let var_name = tcx.hir().name(freevar.var_id());
struct_fmt.field(&var_name.as_str(), place);
@ -2433,11 +2433,12 @@ impl<'tcx> Debug for Rvalue<'tcx> {
}),
AggregateKind::Generator(def_id, _, _) => ty::tls::with(|tcx| {
if let Some(node_id) = tcx.hir().as_local_node_id(def_id) {
let name = format!("[generator@{:?}]", tcx.hir().span(node_id));
if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
let name = format!("[generator@{:?}]",
tcx.hir().span_by_hir_id(hir_id));
let mut struct_fmt = fmt.debug_struct(&name);
tcx.with_freevars(node_id, |freevars| {
tcx.with_freevars(hir_id, |freevars| {
for (freevar, place) in freevars.iter().zip(places) {
let var_name = tcx.hir().name(freevar.var_id());
struct_fmt.field(&var_name.as_str(), place);

4
src/librustc/mir/mono.rs
View file

@ -1,5 +1,5 @@
use crate::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};
use syntax::ast::NodeId;
use crate::hir::HirId;
use syntax::symbol::{Symbol, InternedString};
use crate::ty::{Instance, TyCtxt};
use crate::util::nodemap::FxHashMap;
@ -14,7 +14,7 @@ use std::hash::Hash;
pub enum MonoItem<'tcx> {
Fn(Instance<'tcx>),
Static(DefId),
GlobalAsm(NodeId),
GlobalAsm(HirId),
}
impl<'tcx> MonoItem<'tcx> {

5
src/librustc/traits/error_reporting.rs
View file

@ -761,7 +761,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
let found_kind = self.closure_kind(closure_def_id, closure_substs).unwrap();
let closure_span = self.tcx.sess.source_map()
.def_span(self.tcx.hir().span_if_local(closure_def_id).unwrap());
let node_id = self.tcx.hir().as_local_node_id(closure_def_id).unwrap();
let hir_id = self.tcx.hir().as_local_hir_id(closure_def_id).unwrap();
let mut err = struct_span_err!(
self.tcx.sess, closure_span, E0525,
"expected a closure that implements the `{}` trait, \
@ -780,8 +780,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
// a particular trait.
if let Some(tables) = self.in_progress_tables {
let tables = tables.borrow();
let closure_hir_id = self.tcx.hir().node_to_hir_id(node_id);
match (found_kind, tables.closure_kind_origins().get(closure_hir_id)) {
match (found_kind, tables.closure_kind_origins().get(hir_id)) {
(ty::ClosureKind::FnOnce, Some((span, name))) => {
err.span_label(*span, format!(
"closure is `FnOnce` because it moves the \

6
src/librustc/ty/constness.rs
View file

@ -67,10 +67,10 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
/// only checks whether the function has a `const` modifier
fn is_const_fn_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> bool {
let node_id = tcx.hir().as_local_node_id(def_id)
.expect("Non-local call to local provider is_const_fn");
let hir_id = tcx.hir().as_local_hir_id(def_id)
.expect("Non-local call to local provider is_const_fn");
if let Some(fn_like) = FnLikeNode::from_node(tcx.hir().get(node_id)) {
if let Some(fn_like) = FnLikeNode::from_node(tcx.hir().get_by_hir_id(hir_id)) {
fn_like.constness() == hir::Constness::Const
} else {
false

10
src/librustc/ty/context.rs
View file

@ -1619,10 +1619,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
_ => return None, // not a free region
};
let node_id = self.hir()
.as_local_node_id(suitable_region_binding_scope)
let hir_id = self.hir()
.as_local_hir_id(suitable_region_binding_scope)
.unwrap();
let is_impl_item = match self.hir().find(node_id) {
let is_impl_item = match self.hir().find_by_hir_id(hir_id) {
Some(Node::Item(..)) | Some(Node::TraitItem(..)) => false,
Some(Node::ImplItem(..)) => {
self.is_bound_region_in_impl_item(suitable_region_binding_scope)
@ -1642,8 +1642,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
scope_def_id: DefId,
) -> Option<Ty<'tcx>> {
// HACK: `type_of_def_id()` will fail on these (#55796), so return None
let node_id = self.hir().as_local_node_id(scope_def_id).unwrap();
match self.hir().get(node_id) {
let hir_id = self.hir().as_local_hir_id(scope_def_id).unwrap();
match self.hir().get_by_hir_id(hir_id) {
Node::Item(item) => {
match item.node {
ItemKind::Fn(..) => { /* type_of_def_id() will work */ }

14
src/librustc/ty/mod.rs
View file

@ -5,7 +5,7 @@ pub use self::IntVarValue::*;
pub use self::fold::TypeFoldable;
use crate::hir::{map as hir_map, FreevarMap, GlobMap, TraitMap};
use crate::hir::Node;
use crate::hir::{HirId, Node};
use crate::hir::def::{Def, CtorKind, ExportMap};
use crate::hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use crate::hir::map::DefPathData;
@ -2726,8 +2726,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
}
pub fn opt_associated_item(self, def_id: DefId) -> Option<AssociatedItem> {
let is_associated_item = if let Some(node_id) = self.hir().as_local_node_id(def_id) {
match self.hir().get(node_id) {
let is_associated_item = if let Some(hir_id) = self.hir().as_local_hir_id(def_id) {
match self.hir().get_by_hir_id(hir_id) {
Node::TraitItem(_) | Node::ImplItem(_) => true,
_ => false,
}
@ -3048,10 +3048,10 @@ impl Iterator for AssociatedItemsIterator<'_, '_, '_> {
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
pub fn with_freevars<T, F>(self, fid: NodeId, f: F) -> T where
pub fn with_freevars<T, F>(self, fid: HirId, f: F) -> T where
F: FnOnce(&[hir::Freevar]) -> T,
{
let def_id = self.hir().local_def_id(fid);
let def_id = self.hir().local_def_id_from_hir_id(fid);
match self.freevars(def_id) {
None => f(&[]),
Some(d) => f(&d),
@ -3163,8 +3163,8 @@ fn trait_of_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option
/// Yields the parent function's `DefId` if `def_id` is an `impl Trait` definition.
pub fn is_impl_trait_defn(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Option<DefId> {
if let Some(node_id) = tcx.hir().as_local_node_id(def_id) {
if let Node::Item(item) = tcx.hir().get(node_id) {
if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
if let Node::Item(item) = tcx.hir().get_by_hir_id(hir_id) {
if let hir::ItemKind::Existential(ref exist_ty) = item.node {
return exist_ty.impl_trait_fn;
}

2
src/librustc/ty/query/config.rs
View file

@ -313,7 +313,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::erase_regions_ty<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::type_param_predicates<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, (_, def_id): (DefId, DefId)) -> Cow<'static, str> {
let id = tcx.hir().as_local_node_id(def_id).unwrap();
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
format!("computing the bounds for type parameter `{}`",
tcx.hir().ty_param_name(id)).into()
}

14
src/librustc/util/ppaux.rs
View file

@ -1380,10 +1380,10 @@ define_print! {
write!(f, "[static generator")?;
}
if let Some(node_id) = tcx.hir().as_local_node_id(did) {
write!(f, "@{:?}", tcx.hir().span(node_id))?;
if let Some(hir_id) = tcx.hir().as_local_hir_id(did) {
write!(f, "@{:?}", tcx.hir().span_by_hir_id(hir_id))?;
let mut sep = " ";
tcx.with_freevars(node_id, |freevars| {
tcx.with_freevars(hir_id, |freevars| {
for (freevar, upvar_ty) in freevars.iter().zip(upvar_tys) {
print!(f, cx,
write("{}{}:",
@ -1416,14 +1416,14 @@ define_print! {
let upvar_tys = substs.upvar_tys(did, tcx);
write!(f, "[closure")?;
if let Some(node_id) = tcx.hir().as_local_node_id(did) {
if let Some(hir_id) = tcx.hir().as_local_hir_id(did) {
if tcx.sess.opts.debugging_opts.span_free_formats {
write!(f, "@{:?}", node_id)?;
write!(f, "@{:?}", hir_id)?;
} else {
write!(f, "@{:?}", tcx.hir().span(node_id))?;
write!(f, "@{:?}", tcx.hir().span_by_hir_id(hir_id))?;
}
let mut sep = " ";
tcx.with_freevars(node_id, |freevars| {
tcx.with_freevars(hir_id, |freevars| {
for (freevar, upvar_ty) in freevars.iter().zip(upvar_tys) {
print!(f, cx,
write("{}{}:",

4
src/librustc_borrowck/borrowck/check_loans.rs
View file

@ -188,8 +188,8 @@ pub fn check_loans<'a, 'b, 'c, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
let def_id = bccx.tcx.hir().body_owner_def_id(body.id());
let node_id = bccx.tcx.hir().as_local_node_id(def_id).unwrap();
let movable_generator = !match bccx.tcx.hir().get(node_id) {
let hir_id = bccx.tcx.hir().as_local_hir_id(def_id).unwrap();
let movable_generator = !match bccx.tcx.hir().get_by_hir_id(hir_id) {
Node::Expr(&hir::Expr {
node: hir::ExprKind::Closure(.., Some(hir::GeneratorMovability::Static)),
..

13
src/librustc_borrowck/borrowck/mod.rs
View file

@ -83,9 +83,9 @@ fn borrowck<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, owner_def_id: DefId)
debug!("borrowck(body_owner_def_id={:?})", owner_def_id);
let owner_id = tcx.hir().as_local_node_id(owner_def_id).unwrap();
let owner_id = tcx.hir().as_local_hir_id(owner_def_id).unwrap();
match tcx.hir().get(owner_id) {
match tcx.hir().get_by_hir_id(owner_id) {
Node::StructCtor(_) |
Node::Variant(_) => {
// We get invoked with anything that has MIR, but some of
@ -681,8 +681,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
Origin::Ast);
let need_note = match lp.ty.sty {
ty::Closure(id, _) => {
let node_id = self.tcx.hir().as_local_node_id(id).unwrap();
let hir_id = self.tcx.hir().node_to_hir_id(node_id);
let hir_id = self.tcx.hir().as_local_hir_id(id).unwrap();
if let Some((span, name)) = self.tables.closure_kind_origins().get(hir_id) {
err.span_note(*span, &format!(
"closure cannot be invoked more than once because \
@ -1253,12 +1252,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
}
}
Some(ImmutabilityBlame::AdtFieldDeref(_, field)) => {
let node_id = match self.tcx.hir().as_local_node_id(field.did) {
Some(node_id) => node_id,
let hir_id = match self.tcx.hir().as_local_hir_id(field.did) {
Some(hir_id) => hir_id,
None => return
};
if let Node::Field(ref field) = self.tcx.hir().get(node_id) {
if let Node::Field(ref field) = self.tcx.hir().get_by_hir_id(hir_id) {
if let Some(msg) = self.suggest_mut_for_immutable(&field.ty, false) {
db.span_label(field.ty.span, msg);
}

4
src/librustc_codegen_llvm/consts.rs
View file

@ -213,10 +213,10 @@ impl CodegenCx<'ll, 'tcx> {
debug!("get_static: sym={} instance={:?}", sym, instance);
let g = if let Some(id) = self.tcx.hir().as_local_node_id(def_id) {
let g = if let Some(id) = self.tcx.hir().as_local_hir_id(def_id) {
let llty = self.layout_of(ty).llvm_type(self);
let (g, attrs) = match self.tcx.hir().get(id) {
let (g, attrs) = match self.tcx.hir().get_by_hir_id(id) {
Node::Item(&hir::Item {
ref attrs, span, node: hir::ItemKind::Static(..), ..
}) => {

4
src/librustc_codegen_ssa/mono_item.rs
View file

@ -31,8 +31,8 @@ pub trait MonoItemExt<'a, 'tcx: 'a>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
};
cx.codegen_static(def_id, is_mutable);
}
MonoItem::GlobalAsm(node_id) => {
let item = cx.tcx().hir().expect_item(node_id);
MonoItem::GlobalAsm(hir_id) => {
let item = cx.tcx().hir().expect_item_by_hir_id(hir_id);
if let hir::ItemKind::GlobalAsm(ref ga) = item.node {
cx.codegen_global_asm(ga);
} else {

6
src/librustc_codegen_utils/symbol_names.rs
View file

@ -242,7 +242,7 @@ fn compute_symbol_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: Instance
debug!("symbol_name(def_id={:?}, substs={:?})", def_id, substs);
let node_id = tcx.hir().as_local_node_id(def_id);
let hir_id = tcx.hir().as_local_hir_id(def_id);
if def_id.is_local() {
if tcx.plugin_registrar_fn(LOCAL_CRATE) == Some(def_id) {
@ -256,8 +256,8 @@ fn compute_symbol_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: Instance
}
// FIXME(eddyb) Precompute a custom symbol name based on attributes.
let is_foreign = if let Some(id) = node_id {
match tcx.hir().get(id) {
let is_foreign = if let Some(id) = hir_id {
match tcx.hir().get_by_hir_id(id) {
Node::ForeignItem(_) => true,
_ => false,
}

4
src/librustc_lint/builtin.rs
View file

@ -458,8 +458,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> 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 = trait_ref.path.def.def_id();
if let Some(node_id) = cx.tcx.hir().as_local_node_id(real_trait) {
match cx.tcx.hir().find(node_id) {
if let Some(hir_id) = cx.tcx.hir().as_local_hir_id(real_trait) {
match cx.tcx.hir().find_by_hir_id(hir_id) {
Some(Node::Item(item)) => {
if let hir::VisibilityKind::Inherited = item.vis.node {
for impl_item_ref in impl_item_refs {

13
src/librustc_metadata/encoder.rs
View file

@ -779,8 +779,8 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
debug!("IsolatedEncoder::encode_info_for_trait_item({:?})", def_id);
let tcx = self.tcx;
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let ast_item = tcx.hir().expect_trait_item(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let ast_item = tcx.hir().expect_trait_item_by_hir_id(hir_id);
let trait_item = tcx.associated_item(def_id);
let container = match trait_item.defaultness {
@ -889,8 +889,8 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
debug!("IsolatedEncoder::encode_info_for_impl_item({:?})", def_id);
let tcx = self.tcx;
let node_id = self.tcx.hir().as_local_node_id(def_id).unwrap();
let ast_item = self.tcx.hir().expect_impl_item(node_id);
let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
let ast_item = self.tcx.hir().expect_impl_item_by_hir_id(hir_id);
let impl_item = self.tcx.associated_item(def_id);
let container = match impl_item.defaultness {
@ -1360,8 +1360,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
let tcx = self.tcx;
let tables = self.tcx.typeck_tables_of(def_id);
let node_id = self.tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = self.tcx.hir().node_to_hir_id(node_id);
let hir_id = self.tcx.hir().as_local_hir_id(def_id).unwrap();
let kind = match tables.node_type(hir_id).sty {
ty::Generator(def_id, ..) => {
let layout = self.tcx.generator_layout(def_id);
@ -1403,7 +1402,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
fn encode_info_for_anon_const(&mut self, def_id: DefId) -> Entry<'tcx> {
debug!("IsolatedEncoder::encode_info_for_anon_const({:?})", def_id);
let tcx = self.tcx;
let id = tcx.hir().as_local_node_id(def_id).unwrap();
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let body_id = tcx.hir().body_owned_by(id);
let const_data = self.encode_rendered_const_for_body(body_id);
let mir = tcx.mir_const_qualif(def_id).0;

25
src/librustc_mir/borrow_check/error_reporting.rs
View file

@ -191,8 +191,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
let needs_note = match ty.sty {
ty::Closure(id, _) => {
let tables = self.infcx.tcx.typeck_tables_of(id);
let node_id = self.infcx.tcx.hir().as_local_node_id(id).unwrap();
let hir_id = self.infcx.tcx.hir().node_to_hir_id(node_id);
let hir_id = self.infcx.tcx.hir().as_local_hir_id(id).unwrap();
tables.closure_kind_origins().get(hir_id).is_none()
}
@ -1525,8 +1524,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
debug!("add_moved_or_invoked_closure_note: closure={:?}", closure);
if let ty::TyKind::Closure(did, _) = self.mir.local_decls[closure].ty.sty {
let node_id = self.infcx.tcx.hir().as_local_node_id(did).unwrap();
let hir_id = self.infcx.tcx.hir().node_to_hir_id(node_id);
let hir_id = self.infcx.tcx.hir().as_local_hir_id(did).unwrap();
if let Some((span, name)) = self.infcx.tcx.typeck_tables_of(did)
.closure_kind_origins()
@ -1549,8 +1547,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
// Check if we are just moving a closure after it has been invoked.
if let Some(target) = target {
if let ty::TyKind::Closure(did, _) = self.mir.local_decls[target].ty.sty {
let node_id = self.infcx.tcx.hir().as_local_node_id(did).unwrap();
let hir_id = self.infcx.tcx.hir().node_to_hir_id(node_id);
let hir_id = self.infcx.tcx.hir().as_local_hir_id(did).unwrap();
if let Some((span, name)) = self.infcx.tcx.typeck_tables_of(did)
.closure_kind_origins()
@ -1790,10 +1787,10 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
// the local code in the current crate, so this returns an `Option` in case
// the closure comes from another crate. But in that case we wouldn't
// be borrowck'ing it, so we can just unwrap:
let node_id = self.infcx.tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = self.infcx.tcx.hir().as_local_hir_id(def_id).unwrap();
let freevar = self.infcx
.tcx
.with_freevars(node_id, |fv| fv[field.index()]);
.with_freevars(hir_id, |fv| fv[field.index()]);
self.infcx.tcx.hir().name(freevar.var_id()).to_string()
}
@ -2105,8 +2102,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
) -> Option<AnnotatedBorrowFnSignature<'_>> {
debug!("annotate_fn_sig: did={:?} sig={:?}", did, sig);
let is_closure = self.infcx.tcx.is_closure(did);
let fn_node_id = self.infcx.tcx.hir().as_local_node_id(did)?;
let fn_decl = self.infcx.tcx.hir().fn_decl(fn_node_id)?;
let fn_hir_id = self.infcx.tcx.hir().as_local_hir_id(did)?;
let fn_decl = self.infcx.tcx.hir().fn_decl_by_hir_id(fn_hir_id)?;
// We need to work out which arguments to highlight. We do this by looking
// at the return type, where there are three cases:
@ -2560,14 +2557,14 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
"closure_span: def_id={:?} target_place={:?} places={:?}",
def_id, target_place, places
);
let node_id = self.infcx.tcx.hir().as_local_node_id(def_id)?;
let expr = &self.infcx.tcx.hir().expect_expr(node_id).node;
debug!("closure_span: node_id={:?} expr={:?}", node_id, expr);
let hir_id = self.infcx.tcx.hir().as_local_hir_id(def_id)?;
let expr = &self.infcx.tcx.hir().expect_expr_by_hir_id(hir_id).node;
debug!("closure_span: hir_id={:?} expr={:?}", hir_id, expr);
if let hir::ExprKind::Closure(
.., args_span, _
) = expr {
let var_span = self.infcx.tcx.with_freevars(
node_id,
hir_id,
|freevars| {
for (v, place) in freevars.iter().zip(places) {
match place {

6
src/librustc_mir/borrow_check/mod.rs
View file

@ -128,7 +128,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
let param_env = tcx.param_env(def_id);
let id = tcx
.hir()
.as_local_node_id(def_id)
.as_local_hir_id(def_id)
.expect("do_mir_borrowck: non-local DefId");
// Replace all regions with fresh inference variables. This
@ -163,7 +163,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
));
let locals_are_invalidated_at_exit = tcx.hir().body_owner_kind(id).is_fn_or_closure();
let locals_are_invalidated_at_exit = tcx.hir().body_owner_kind_by_hir_id(id).is_fn_or_closure();
let borrow_set = Rc::new(BorrowSet::build(
tcx, mir, locals_are_invalidated_at_exit, &mdpe.move_data));
@ -216,7 +216,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
|bd, i| DebugFormatted::new(&bd.move_data().inits[i]),
));
let movable_generator = match tcx.hir().get(id) {
let movable_generator = match tcx.hir().get_by_hir_id(id) {
Node::Expr(&hir::Expr {
node: hir::ExprKind::Closure(.., Some(hir::GeneratorMovability::Static)),
..

4
src/librustc_mir/borrow_check/mutability_errors.rs
View file

@ -635,8 +635,8 @@ fn annotate_struct_field(
if let ty::TyKind::Adt(def, _) = ty.sty {
let field = def.all_fields().nth(field.index())?;
// Use the HIR types to construct the diagnostic message.
let node_id = tcx.hir().as_local_node_id(field.did)?;
let node = tcx.hir().find(node_id)?;
let hir_id = tcx.hir().as_local_hir_id(field.did)?;
let node = tcx.hir().find_by_hir_id(hir_id)?;
// Now we're dealing with the actual struct that we're going to suggest a change to,
// we can expect a field that is an immutable reference to a type.
if let hir::Node::Field(field) = node {

38
src/librustc_mir/build/mod.rs
View file

@ -28,10 +28,10 @@ use super::lints;
/// Construct the MIR for a given `DefId`.
pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'tcx> {
let id = tcx.hir().as_local_node_id(def_id).unwrap();
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
// Figure out what primary body this item has.
let (body_id, return_ty_span) = match tcx.hir().get(id) {
let (body_id, return_ty_span) = match tcx.hir().get_by_hir_id(id) {
Node::Variant(variant) =>
return create_constructor_shim(tcx, id, &variant.node.data),
Node::StructCtor(ctor) =>
@ -68,19 +68,18 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t
(*body, tcx.hir().span_by_hir_id(*hir_id))
}
_ => span_bug!(tcx.hir().span(id), "can't build MIR for {:?}", def_id),
_ => span_bug!(tcx.hir().span_by_hir_id(id), "can't build MIR for {:?}", def_id),
};
tcx.infer_ctxt().enter(|infcx| {
let fn_hir_id = tcx.hir().node_to_hir_id(id);
let cx = Cx::new(&infcx, fn_hir_id);
let cx = Cx::new(&infcx, id);
let mut mir = if cx.tables().tainted_by_errors {
build::construct_error(cx, body_id)
} else if cx.body_owner_kind.is_fn_or_closure() {
// fetch the fully liberated fn signature (that is, all bound
// types/lifetimes replaced)
let fn_sig = cx.tables().liberated_fn_sigs()[fn_hir_id].clone();
let fn_def_id = tcx.hir().local_def_id(id);
let fn_sig = cx.tables().liberated_fn_sigs()[id].clone();
let fn_def_id = tcx.hir().local_def_id_from_hir_id(id);
let ty = tcx.type_of(fn_def_id);
let mut abi = fn_sig.abi;
@ -92,7 +91,7 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t
Some(ArgInfo(liberated_closure_env_ty(tcx, id, body_id), None, None, None))
}
ty::Generator(..) => {
let gen_ty = tcx.body_tables(body_id).node_type(fn_hir_id);
let gen_ty = tcx.body_tables(body_id).node_type(id);
Some(ArgInfo(gen_ty, None, None, None))
}
_ => None,
@ -141,7 +140,8 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t
ty::Generator(gen_def_id, gen_substs, ..) =>
gen_substs.sig(gen_def_id, tcx),
_ =>
span_bug!(tcx.hir().span(id), "generator w/o generator type: {:?}", ty),
span_bug!(tcx.hir().span_by_hir_id(id),
"generator w/o generator type: {:?}", ty),
};
(Some(gen_sig.yield_ty), gen_sig.return_ty)
} else {
@ -224,11 +224,11 @@ impl<'a, 'gcx: 'tcx, 'tcx> MutVisitor<'tcx> for GlobalizeMir<'a, 'gcx> {
}
fn create_constructor_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ctor_id: ast::NodeId,
ctor_id: hir::HirId,
v: &'tcx hir::VariantData)
-> Mir<'tcx>
{
let span = tcx.hir().span(ctor_id);
let span = tcx.hir().span_by_hir_id(ctor_id);
if let hir::VariantData::Tuple(ref fields, ctor_id) = *v {
tcx.infer_ctxt().enter(|infcx| {
let mut mir = shim::build_adt_ctor(&infcx, ctor_id, fields, span);
@ -259,11 +259,10 @@ fn create_constructor_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// BuildMir -- walks a crate, looking for fn items and methods to build MIR from
fn liberated_closure_env_ty<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
closure_expr_id: ast::NodeId,
closure_expr_id: hir::HirId,
body_id: hir::BodyId)
-> Ty<'tcx> {
let closure_expr_hir_id = tcx.hir().node_to_hir_id(closure_expr_id);
let closure_ty = tcx.body_tables(body_id).node_type(closure_expr_hir_id);
let closure_ty = tcx.body_tables(body_id).node_type(closure_expr_id);
let (closure_def_id, closure_substs) = match closure_ty.sty {
ty::Closure(closure_def_id, closure_substs) => (closure_def_id, closure_substs),
@ -606,7 +605,7 @@ struct ArgInfo<'gcx>(Ty<'gcx>,
Option<ImplicitSelfKind>);
fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
fn_id: ast::NodeId,
fn_id: hir::HirId,
arguments: A,
safety: Safety,
abi: Abi,
@ -621,10 +620,10 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
let tcx = hir.tcx();
let tcx_hir = tcx.hir();
let span = tcx_hir.span(fn_id);
let span = tcx_hir.span_by_hir_id(fn_id);
let hir_tables = hir.tables();
let fn_def_id = tcx_hir.local_def_id(fn_id);
let fn_def_id = tcx_hir.local_def_id_from_hir_id(fn_id);
// Gather the upvars of a closure, if any.
// In analyze_closure() in upvar.rs we gathered a list of upvars used by a
@ -718,9 +717,8 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
// RustCall pseudo-ABI untuples the last argument.
spread_arg = Some(Local::new(arguments.len()));
}
let closure_expr_id = tcx_hir.local_def_id(fn_id);
info!("fn_id {:?} has attrs {:?}", closure_expr_id,
tcx.get_attrs(closure_expr_id));
info!("fn_id {:?} has attrs {:?}", fn_def_id,
tcx.get_attrs(fn_def_id));
let mut mir = builder.finish(yield_ty);
mir.spread_arg = spread_arg;

4
src/librustc_mir/const_eval.rs
View file

@ -617,7 +617,7 @@ pub fn const_eval_raw_provider<'a, 'tcx>(
let cid = key.value;
let def_id = cid.instance.def.def_id();
if let Some(id) = tcx.hir().as_local_node_id(def_id) {
if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
let tables = tcx.typeck_tables_of(def_id);
// Do match-check before building MIR
@ -625,7 +625,7 @@ pub fn const_eval_raw_provider<'a, 'tcx>(
return Err(ErrorHandled::Reported)
}
if let hir::BodyOwnerKind::Const = tcx.hir().body_owner_kind(id) {
if let hir::BodyOwnerKind::Const = tcx.hir().body_owner_kind_by_hir_id(id) {
tcx.mir_const_qualif(def_id);
}

12
src/librustc_mir/dataflow/graphviz.rs
View file

@ -1,6 +1,6 @@
//! Hook into libgraphviz for rendering dataflow graphs for MIR.
use syntax::ast::NodeId;
use rustc::hir::HirId;
use rustc::mir::{BasicBlock, Mir};
use std::fs;
@ -14,7 +14,7 @@ use super::DebugFormatted;
pub trait MirWithFlowState<'tcx> {
type BD: BitDenotation<'tcx>;
fn node_id(&self) -> NodeId;
fn hir_id(&self) -> HirId;
fn mir(&self) -> &Mir<'tcx>;
fn flow_state(&self) -> &DataflowState<'tcx, Self::BD>;
}
@ -23,7 +23,7 @@ impl<'a, 'tcx, BD> MirWithFlowState<'tcx> for DataflowBuilder<'a, 'tcx, BD>
where BD: BitDenotation<'tcx>
{
type BD = BD;
fn node_id(&self) -> NodeId { self.node_id }
fn hir_id(&self) -> HirId { self.hir_id }
fn mir(&self) -> &Mir<'tcx> { self.flow_state.mir() }
fn flow_state(&self) -> &DataflowState<'tcx, Self::BD> { &self.flow_state.flow_state }
}
@ -47,8 +47,8 @@ pub(crate) fn print_borrowck_graph_to<'a, 'tcx, BD, P>(
let g = Graph { mbcx, phantom: PhantomData, render_idx };
let mut v = Vec::new();
dot::render(&g, &mut v)?;
debug!("print_borrowck_graph_to path: {} node_id: {}",
path.display(), mbcx.node_id);
debug!("print_borrowck_graph_to path: {} hir_id: {}",
path.display(), mbcx.hir_id);
fs::write(path, v)
}
@ -70,7 +70,7 @@ impl<'a, 'tcx, MWF, P> dot::Labeller<'a> for Graph<'a, 'tcx, MWF, P>
type Edge = Edge;
fn graph_id(&self) -> dot::Id<'_> {
dot::Id::new(format!("graph_for_node_{}",
self.mbcx.node_id()))
self.mbcx.hir_id()))
.unwrap()
}

11
src/librustc_mir/dataflow/mod.rs
View file

@ -4,6 +4,7 @@ use rustc_data_structures::bit_set::{BitSet, BitSetOperator, HybridBitSet};
use rustc_data_structures::indexed_vec::Idx;
use rustc_data_structures::work_queue::WorkQueue;
use rustc::hir::HirId;
use rustc::ty::{self, TyCtxt};
use rustc::mir::{self, Mir, BasicBlock, BasicBlockData, Location, Statement, Terminator};
use rustc::mir::traversal;
@ -38,7 +39,7 @@ pub(crate) struct DataflowBuilder<'a, 'tcx: 'a, BD>
where
BD: BitDenotation<'tcx>
{
node_id: ast::NodeId,
hir_id: HirId,
flow_state: DataflowAnalysis<'a, 'tcx, BD>,
print_preflow_to: Option<String>,
print_postflow_to: Option<String>,
@ -116,7 +117,7 @@ pub struct MoveDataParamEnv<'gcx, 'tcx> {
pub(crate) fn do_dataflow<'a, 'gcx, 'tcx, BD, P>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
node_id: ast::NodeId,
hir_id: HirId,
attributes: &[ast::Attribute],
dead_unwinds: &BitSet<BasicBlock>,
bd: BD,
@ -126,14 +127,14 @@ pub(crate) fn do_dataflow<'a, 'gcx, 'tcx, BD, P>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
P: Fn(&BD, BD::Idx) -> DebugFormatted
{
let flow_state = DataflowAnalysis::new(mir, dead_unwinds, bd);
flow_state.run(tcx, node_id, attributes, p)
flow_state.run(tcx, hir_id, attributes, p)
}
impl<'a, 'gcx: 'tcx, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitDenotation<'tcx>
{
pub(crate) fn run<P>(self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
node_id: ast::NodeId,
hir_id: HirId,
attributes: &[ast::Attribute],
p: P) -> DataflowResults<'tcx, BD>
where P: Fn(&BD, BD::Idx) -> DebugFormatted
@ -158,7 +159,7 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a, BD> DataflowAnalysis<'a, 'tcx, BD> where BD: BitD
name_found(tcx.sess, attributes, "borrowck_graphviz_postflow");
let mut mbcx = DataflowBuilder {
node_id,
hir_id,
print_preflow_to, print_postflow_to, flow_state: self,
};

3
src/librustc_mir/hair/cx/expr.rs
View file

@ -530,8 +530,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
span_bug!(expr.span, "closure expr w/o closure type: {:?}", closure_ty);
}
};
let expr_node_id = cx.tcx.hir().hir_to_node_id(expr.hir_id);
let upvars = cx.tcx.with_freevars(expr_node_id, |freevars| {
let upvars = cx.tcx.with_freevars(expr.hir_id, |freevars| {
freevars.iter()
.zip(substs.upvar_tys(def_id, cx.tcx))
.map(|(fv, ty)| capture_freevar(cx, expr, fv, ty))

2
src/librustc_mir/hair/pattern/check_match.rs
View file

@ -38,7 +38,7 @@ pub(crate) fn check_match<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
) -> Result<(), ErrorReported> {
let body_id = if let Some(id) = tcx.hir().as_local_node_id(def_id) {
let body_id = if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
tcx.hir().body_owned_by(id)
} else {
return Ok(());

4
src/librustc_mir/lints.rs
View file

@ -10,9 +10,9 @@ use rustc::ty::subst::InternalSubsts;
pub fn check(tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &Mir<'tcx>,
def_id: DefId) {
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
if let Some(fn_like_node) = FnLikeNode::from_node(tcx.hir().get(node_id)) {
if let Some(fn_like_node) = FnLikeNode::from_node(tcx.hir().get_by_hir_id(hir_id)) {
check_fn_for_unconditional_recursion(tcx, fn_like_node.kind(), mir, def_id);
}
}

3
src/librustc_mir/monomorphize/collector.rs
View file

@ -976,8 +976,7 @@ impl<'b, 'a, 'v> ItemLikeVisitor<'v> for RootCollector<'b, 'a, 'v> {
debug!("RootCollector: ItemKind::GlobalAsm({})",
def_id_to_string(self.tcx,
self.tcx.hir().local_def_id_from_hir_id(item.hir_id)));
let node_id = self.tcx.hir().hir_to_node_id(item.hir_id);
self.output.push(MonoItem::GlobalAsm(node_id));
self.output.push(MonoItem::GlobalAsm(item.hir_id));
}
hir::ItemKind::Static(..) => {
let def_id = self.tcx.hir().local_def_id_from_hir_id(item.hir_id);

14
src/librustc_mir/monomorphize/item.rs
View file

@ -58,8 +58,8 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug {
MonoItem::Static(def_id) => {
tcx.symbol_name(Instance::mono(tcx, def_id))
}
MonoItem::GlobalAsm(node_id) => {
let def_id = tcx.hir().local_def_id(node_id);
MonoItem::GlobalAsm(hir_id) => {
let def_id = tcx.hir().local_def_id_from_hir_id(hir_id);
ty::SymbolName {
name: Symbol::intern(&format!("global_asm_{:?}", def_id)).as_interned_str()
}
@ -190,15 +190,15 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug {
fn local_span(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Option<Span> {
match *self.as_mono_item() {
MonoItem::Fn(Instance { def, .. }) => {
tcx.hir().as_local_node_id(def.def_id())
tcx.hir().as_local_hir_id(def.def_id())
}
MonoItem::Static(def_id) => {
tcx.hir().as_local_node_id(def_id)
tcx.hir().as_local_hir_id(def_id)
}
MonoItem::GlobalAsm(node_id) => {
Some(node_id)
MonoItem::GlobalAsm(hir_id) => {
Some(hir_id)
}
}.map(|node_id| tcx.hir().span(node_id))
}.map(|hir_id| tcx.hir().span_by_hir_id(hir_id))
}
}

21
src/librustc_mir/monomorphize/partitioning.rs
View file

@ -96,10 +96,9 @@ use std::collections::hash_map::Entry;
use std::cmp;
use std::sync::Arc;
use syntax::ast::NodeId;
use syntax::symbol::InternedString;
use rustc::dep_graph::{WorkProductId, WorkProduct, DepNode, DepConstructor};
use rustc::hir::CodegenFnAttrFlags;
use rustc::hir::{CodegenFnAttrFlags, HirId};
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE, CRATE_DEF_INDEX};
use rustc::hir::map::DefPathData;
use rustc::mir::mono::{Linkage, Visibility, CodegenUnitNameBuilder};
@ -162,19 +161,19 @@ pub trait CodegenUnitExt<'tcx> {
// The codegen tests rely on items being process in the same order as
// they appear in the file, so for local items, we sort by node_id first
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct ItemSortKey(Option<NodeId>, ty::SymbolName);
pub struct ItemSortKey(Option<HirId>, ty::SymbolName);
fn item_sort_key<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item: MonoItem<'tcx>) -> ItemSortKey {
ItemSortKey(match item {
MonoItem::Fn(ref instance) => {
match instance.def {
// We only want to take NodeIds of user-defined
// We only want to take HirIds of user-defined
// instances into account. The others don't matter for
// the codegen tests and can even make item order
// unstable.
InstanceDef::Item(def_id) => {
tcx.hir().as_local_node_id(def_id)
tcx.hir().as_local_hir_id(def_id)
}
InstanceDef::VtableShim(..) |
InstanceDef::Intrinsic(..) |
@ -188,10 +187,10 @@ pub trait CodegenUnitExt<'tcx> {
}
}
MonoItem::Static(def_id) => {
tcx.hir().as_local_node_id(def_id)
tcx.hir().as_local_hir_id(def_id)
}
MonoItem::GlobalAsm(node_id) => {
Some(node_id)
MonoItem::GlobalAsm(hir_id) => {
Some(hir_id)
}
}, item.symbol_name(tcx))
}
@ -404,8 +403,8 @@ fn mono_item_visibility(
Visibility::Hidden
};
}
MonoItem::GlobalAsm(node_id) => {
let def_id = tcx.hir().local_def_id(*node_id);
MonoItem::GlobalAsm(hir_id) => {
let def_id = tcx.hir().local_def_id_from_hir_id(*hir_id);
return if tcx.is_reachable_non_generic(def_id) {
*can_be_internalized = false;
default_visibility(tcx, def_id, false)
@ -789,7 +788,7 @@ fn characteristic_def_id_of_mono_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
Some(def_id)
}
MonoItem::Static(def_id) => Some(def_id),
MonoItem::GlobalAsm(node_id) => Some(tcx.hir().local_def_id(node_id)),
MonoItem::GlobalAsm(hir_id) => Some(tcx.hir().local_def_id_from_hir_id(hir_id)),
}
}

4
src/librustc_mir/transform/check_unsafety.rs
View file

@ -533,8 +533,8 @@ fn unsafety_check_result<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
let param_env = tcx.param_env(def_id);
let id = tcx.hir().as_local_node_id(def_id).unwrap();
let (const_context, min_const_fn) = match tcx.hir().body_owner_kind(id) {
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let (const_context, min_const_fn) = match tcx.hir().body_owner_kind_by_hir_id(id) {
hir::BodyOwnerKind::Closure => (false, false),
hir::BodyOwnerKind::Fn => (tcx.is_const_fn(def_id), tcx.is_min_const_fn(def_id)),
hir::BodyOwnerKind::Const |

6
src/librustc_mir/transform/const_prop.rs
View file

@ -37,10 +37,10 @@ impl MirPass for ConstProp {
}
use rustc::hir::map::blocks::FnLikeNode;
let node_id = tcx.hir().as_local_node_id(source.def_id())
.expect("Non-local call to local provider is_const_fn");
let hir_id = tcx.hir().as_local_hir_id(source.def_id())
.expect("Non-local call to local provider is_const_fn");
let is_fn_like = FnLikeNode::from_node(tcx.hir().get(node_id)).is_some();
let is_fn_like = FnLikeNode::from_node(tcx.hir().get_by_hir_id(hir_id)).is_some();
let is_assoc_const = match tcx.describe_def(source.def_id()) {
Some(Def::AssociatedConst(_)) => true,
_ => false,

6
src/librustc_mir/transform/elaborate_drops.rs
View file

@ -11,11 +11,11 @@ use crate::util::elaborate_drops::{DropFlagState, Unwind, elaborate_drop};
use crate::util::elaborate_drops::{DropElaborator, DropStyle, DropFlagMode};
use rustc::ty::{self, TyCtxt};
use rustc::ty::layout::VariantIdx;
use rustc::hir;
use rustc::mir::*;
use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::bit_set::BitSet;
use std::fmt;
use syntax::ast;
use syntax_pos::Span;
pub struct ElaborateDrops;
@ -28,7 +28,7 @@ impl MirPass for ElaborateDrops {
{
debug!("elaborate_drops({:?} @ {:?})", src, mir.span);
let id = tcx.hir().as_local_node_id(src.def_id()).unwrap();
let id = tcx.hir().as_local_hir_id(src.def_id()).unwrap();
let param_env = tcx.param_env(src.def_id()).with_reveal_all();
let move_data = match MoveData::gather_moves(mir, tcx) {
Ok(move_data) => move_data,
@ -80,7 +80,7 @@ impl MirPass for ElaborateDrops {
fn find_dead_unwinds<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &Mir<'tcx>,
id: ast::NodeId,
id: hir::HirId,
env: &MoveDataParamEnv<'tcx, 'tcx>)
-> BitSet<BasicBlock>
{

6
src/librustc_mir/transform/generator.rs
View file

@ -383,13 +383,13 @@ fn locals_live_across_suspend_points(
FxHashMap<BasicBlock, liveness::LiveVarSet>,
) {
let dead_unwinds = BitSet::new_empty(mir.basic_blocks().len());
let node_id = tcx.hir().as_local_node_id(source.def_id()).unwrap();
let hir_id = tcx.hir().as_local_hir_id(source.def_id()).unwrap();
// Calculate when MIR locals have live storage. This gives us an upper bound of their
// lifetimes.
let storage_live_analysis = MaybeStorageLive::new(mir);
let storage_live =
do_dataflow(tcx, mir, node_id, &[], &dead_unwinds, storage_live_analysis,
do_dataflow(tcx, mir, hir_id, &[], &dead_unwinds, storage_live_analysis,
|bd, p| DebugFormatted::new(&bd.mir().local_decls[p]));
// Find the MIR locals which do not use StorageLive/StorageDead statements.
@ -403,7 +403,7 @@ fn locals_live_across_suspend_points(
let borrowed_locals = if !movable {
let analysis = HaveBeenBorrowedLocals::new(mir);
let result =
do_dataflow(tcx, mir, node_id, &[], &dead_unwinds, analysis,
do_dataflow(tcx, mir, hir_id, &[], &dead_unwinds, analysis,
|bd, p| DebugFormatted::new(&bd.mir().local_decls[p]));
Some((analysis, result))
} else {

6
src/librustc_mir/transform/inline.rs
View file

@ -72,8 +72,10 @@ impl<'a, 'tcx> Inliner<'a, 'tcx> {
let param_env = self.tcx.param_env(self.source.def_id());
// Only do inlining into fn bodies.
let id = self.tcx.hir().as_local_node_id(self.source.def_id()).unwrap();
if self.tcx.hir().body_owner_kind(id).is_fn_or_closure() && self.source.promoted.is_none() {
let id = self.tcx.hir().as_local_hir_id(self.source.def_id()).unwrap();
if self.tcx.hir().body_owner_kind_by_hir_id(id).is_fn_or_closure()
&& self.source.promoted.is_none()
{
for (bb, bb_data) in caller_mir.basic_blocks().iter_enumerated() {
if let Some(callsite) = self.get_valid_function_call(bb,
bb_data,

4
src/librustc_mir/transform/mod.rs
View file

@ -214,8 +214,8 @@ fn mir_const<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx Stea
}
fn mir_validated<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx Steal<Mir<'tcx>> {
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
if let hir::BodyOwnerKind::Const = tcx.hir().body_owner_kind(node_id) {
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
if let hir::BodyOwnerKind::Const = tcx.hir().body_owner_kind_by_hir_id(hir_id) {
// Ensure that we compute the `mir_const_qualif` for constants at
// this point, before we steal the mir-const result.
let _ = tcx.mir_const_qualif(def_id);

5
src/librustc_mir/transform/rustc_peek.rs
View file

@ -3,6 +3,7 @@ use syntax::ast;
use syntax_pos::Span;
use rustc::ty::{self, TyCtxt};
use rustc::hir;
use rustc::mir::{self, Mir, Location};
use rustc_data_structures::bit_set::BitSet;
use crate::transform::{MirPass, MirSource};
@ -26,7 +27,7 @@ impl MirPass for SanityCheck {
fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>,
src: MirSource<'tcx>, mir: &mut Mir<'tcx>) {
let def_id = src.def_id();
let id = tcx.hir().as_local_node_id(def_id).unwrap();
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
if !tcx.has_attr(def_id, "rustc_mir") {
debug!("skipping rustc_peek::SanityCheck on {}", tcx.item_path_str(def_id));
return;
@ -85,7 +86,7 @@ impl MirPass for SanityCheck {
/// errors are not intended to be used for unit tests.)
pub fn sanity_check_via_rustc_peek<'a, 'tcx, O>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &Mir<'tcx>,
id: ast::NodeId,
id: hir::HirId,
_attributes: &[ast::Attribute],
results: &DataflowResults<'tcx, O>)
where O: BitDenotation<'tcx, Idx=MovePathIndex> + HasMoveData<'tcx>

2
src/librustc_mir/util/graphviz.rs
View file

@ -27,7 +27,7 @@ pub fn write_mir_fn_graphviz<'tcx, W>(tcx: TyCtxt<'_, '_, 'tcx>,
w: &mut W) -> io::Result<()>
where W: Write
{
writeln!(w, "digraph Mir_{} {{", tcx.hir().as_local_node_id(def_id).unwrap())?;
writeln!(w, "digraph Mir_{} {{", tcx.hir().as_local_hir_id(def_id).unwrap())?;
// Global graph properties
writeln!(w, r#" graph [fontname="monospace"];"#)?;

2
src/librustc_mir/util/liveness.rs
View file

@ -282,7 +282,7 @@ fn dump_matched_mir_node<'a, 'tcx>(
) {
let mut file_path = PathBuf::new();
file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
let item_id = tcx.hir().as_local_node_id(source.def_id()).unwrap();
let item_id = tcx.hir().as_local_hir_id(source.def_id()).unwrap();
let file_name = format!("rustc.node{}{}-liveness.mir", item_id, pass_name);
file_path.push(&file_name);
let _ = fs::File::create(&file_path).and_then(|mut file| {

11
src/librustc_passes/rvalue_promotion.rs
View file

@ -52,9 +52,9 @@ fn const_is_rvalue_promotable_to_static<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
{
assert!(def_id.is_local());
let node_id = tcx.hir().as_local_node_id(def_id)
let hir_id = tcx.hir().as_local_hir_id(def_id)
.expect("rvalue_promotable_map invoked with non-local def-id");
let body_id = tcx.hir().body_owned_by(node_id);
let body_id = tcx.hir().body_owned_by(hir_id);
tcx.rvalue_promotable_map(def_id).contains(&body_id.hir_id.local_id)
}
@ -79,9 +79,9 @@ fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
};
// `def_id` should be a `Body` owner
let node_id = tcx.hir().as_local_node_id(def_id)
let hir_id = tcx.hir().as_local_hir_id(def_id)
.expect("rvalue_promotable_map invoked with non-local def-id");
let body_id = tcx.hir().body_owned_by(node_id);
let body_id = tcx.hir().body_owned_by(hir_id);
let _ = visitor.check_nested_body(body_id);
Lrc::new(visitor.result)
@ -455,10 +455,9 @@ fn check_expr_kind<'a, 'tcx>(
hir::ExprKind::Closure(_capture_clause, ref _box_fn_decl,
body_id, _span, _option_generator_movability) => {
let nested_body_promotable = v.check_nested_body(body_id);
let node_id = v.tcx.hir().hir_to_node_id(e.hir_id);
// Paths in constant contexts cannot refer to local variables,
// as there are none, and thus closures can't have upvars there.
if v.tcx.with_freevars(node_id, |fv| !fv.is_empty()) {
if v.tcx.with_freevars(e.hir_id, |fv| !fv.is_empty()) {
NotPromotable
} else {
nested_body_promotable

4
src/librustc_privacy/lib.rs
View file

@ -1182,10 +1182,10 @@ impl<'a, 'tcx> ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
// A path can only be private if:
// it's in this crate...
if let Some(node_id) = self.tcx.hir().as_local_node_id(did) {
if let Some(hir_id) = self.tcx.hir().as_local_hir_id(did) {
// .. and it corresponds to a private type in the AST (this returns
// `None` for type parameters).
match self.tcx.hir().find(node_id) {
match self.tcx.hir().find_by_hir_id(hir_id) {
Some(Node::Item(ref item)) => !item.vis.node.is_pub(),
Some(_) | None => false,
}

4
src/librustc_traits/lowering/environment.rs
View file

@ -213,8 +213,8 @@ crate fn environment<'a, 'tcx>(
// could bound lifetimes.
.map(Clause::ForAll);
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let node = tcx.hir().get(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let node = tcx.hir().get_by_hir_id(hir_id);
enum NodeKind {
TraitImpl,

4
src/librustc_typeck/astconv.rs
View file

@ -1223,8 +1223,8 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o {
let suitable_bounds = traits::transitive_bounds(tcx, bounds)
.filter(|b| self.trait_defines_associated_type_named(b.def_id(), assoc_name));
let param_node_id = tcx.hir().as_local_node_id(ty_param_def_id).unwrap();
let param_name = tcx.hir().ty_param_name(param_node_id);
let param_hir_id = tcx.hir().as_local_hir_id(ty_param_def_id).unwrap();
let param_name = tcx.hir().ty_param_name(param_hir_id);
self.one_bound_for_assoc_type(suitable_bounds,
&param_name.as_str(),
assoc_name,

4
src/librustc_typeck/check/coercion.rs
View file

@ -712,9 +712,9 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
let b = self.shallow_resolve(b);
let node_id_a = self.tcx.hir().as_local_node_id(def_id_a).unwrap();
let hir_id_a = self.tcx.hir().as_local_hir_id(def_id_a).unwrap();
match b.sty {
ty::FnPtr(_) if self.tcx.with_freevars(node_id_a, |v| v.is_empty()) => {
ty::FnPtr(_) if self.tcx.with_freevars(hir_id_a, |v| v.is_empty()) => {
// We coerce the closure, which has fn type
// `extern "rust-call" fn((arg0,arg1,...)) -> _`
// to

40
src/librustc_typeck/check/compare_method.rs
View file

@ -83,8 +83,7 @@ fn compare_predicate_entailment<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// This node-id should be used for the `body_id` field on each
// `ObligationCause` (and the `FnCtxt`). This is what
// `regionck_item` expects.
let impl_m_node_id = tcx.hir().as_local_node_id(impl_m.def_id).unwrap();
let impl_m_hir_id = tcx.hir().node_to_hir_id(impl_m_node_id);
let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id).unwrap();
let cause = ObligationCause {
span: impl_m_span,
@ -416,8 +415,10 @@ fn extract_spans_for_error_reporting<'a, 'gcx, 'tcx>(infcx: &infer::InferCtxt<'a
trait_sig: ty::FnSig<'tcx>)
-> (Span, Option<Span>) {
let tcx = infcx.tcx;
let impl_m_node_id = tcx.hir().as_local_node_id(impl_m.def_id).unwrap();
let (impl_m_output, impl_m_iter) = match tcx.hir().expect_impl_item(impl_m_node_id).node {
let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id).unwrap();
let (impl_m_output, impl_m_iter) = match tcx.hir()
.expect_impl_item_by_hir_id(impl_m_hir_id)
.node {
ImplItemKind::Method(ref impl_m_sig, _) => {
(&impl_m_sig.decl.output, impl_m_sig.decl.inputs.iter())
}
@ -426,8 +427,10 @@ fn extract_spans_for_error_reporting<'a, 'gcx, 'tcx>(infcx: &infer::InferCtxt<'a
match *terr {
TypeError::Mutability => {
if let Some(trait_m_node_id) = tcx.hir().as_local_node_id(trait_m.def_id) {
let trait_m_iter = match tcx.hir().expect_trait_item(trait_m_node_id).node {
if let Some(trait_m_hir_id) = tcx.hir().as_local_hir_id(trait_m.def_id) {
let trait_m_iter = match tcx.hir()
.expect_trait_item_by_hir_id(trait_m_hir_id)
.node {
TraitItemKind::Method(ref trait_m_sig, _) => {
trait_m_sig.decl.inputs.iter()
}
@ -451,9 +454,9 @@ fn extract_spans_for_error_reporting<'a, 'gcx, 'tcx>(infcx: &infer::InferCtxt<'a
}
}
TypeError::Sorts(ExpectedFound { .. }) => {
if let Some(trait_m_node_id) = tcx.hir().as_local_node_id(trait_m.def_id) {
if let Some(trait_m_hir_id) = tcx.hir().as_local_hir_id(trait_m.def_id) {
let (trait_m_output, trait_m_iter) =
match tcx.hir().expect_trait_item(trait_m_node_id).node {
match tcx.hir().expect_trait_item_by_hir_id(trait_m_hir_id).node {
TraitItemKind::Method(ref trait_m_sig, _) => {
(&trait_m_sig.decl.output, trait_m_sig.decl.inputs.iter())
}
@ -661,9 +664,9 @@ fn compare_number_of_method_arguments<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
let trait_number_args = trait_m_fty.inputs().skip_binder().len();
let impl_number_args = impl_m_fty.inputs().skip_binder().len();
if trait_number_args != impl_number_args {
let trait_m_node_id = tcx.hir().as_local_node_id(trait_m.def_id);
let trait_span = if let Some(trait_id) = trait_m_node_id {
match tcx.hir().expect_trait_item(trait_id).node {
let trait_m_hir_id = tcx.hir().as_local_hir_id(trait_m.def_id);
let trait_span = if let Some(trait_id) = trait_m_hir_id {
match tcx.hir().expect_trait_item_by_hir_id(trait_id).node {
TraitItemKind::Method(ref trait_m_sig, _) => {
let pos = if trait_number_args > 0 {
trait_number_args - 1
@ -687,8 +690,8 @@ fn compare_number_of_method_arguments<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
} else {
trait_item_span
};
let impl_m_node_id = tcx.hir().as_local_node_id(impl_m.def_id).unwrap();
let impl_span = match tcx.hir().expect_impl_item(impl_m_node_id).node {
let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id).unwrap();
let impl_span = match tcx.hir().expect_impl_item_by_hir_id(impl_m_hir_id).node {
ImplItemKind::Method(ref impl_m_sig, _) => {
let pos = if impl_number_args > 0 {
impl_number_args - 1
@ -927,8 +930,7 @@ pub fn compare_const_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
// Create a parameter environment that represents the implementation's
// method.
let impl_c_node_id = tcx.hir().as_local_node_id(impl_c.def_id).unwrap();
let impl_c_hir_id = tcx.hir().node_to_hir_id(impl_c_node_id);
let impl_c_hir_id = tcx.hir().as_local_hir_id(impl_c.def_id).unwrap();
// Compute placeholder form of impl and trait const tys.
let impl_ty = tcx.type_of(impl_c.def_id);
@ -960,7 +962,7 @@ pub fn compare_const_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
trait_ty);
// Locate the Span containing just the type of the offending impl
match tcx.hir().expect_impl_item(impl_c_node_id).node {
match tcx.hir().expect_impl_item_by_hir_id(impl_c_hir_id).node {
ImplItemKind::Const(ref ty, _) => cause.span = ty.span,
_ => bug!("{:?} is not a impl const", impl_c),
}
@ -972,10 +974,10 @@ pub fn compare_const_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
trait",
trait_c.ident);
let trait_c_node_id = tcx.hir().as_local_node_id(trait_c.def_id);
let trait_c_span = trait_c_node_id.map(|trait_c_node_id| {
let trait_c_hir_id = tcx.hir().as_local_hir_id(trait_c.def_id);
let trait_c_span = trait_c_hir_id.map(|trait_c_hir_id| {
// Add a label to the Span containing just the type of the const
match tcx.hir().expect_trait_item(trait_c_node_id).node {
match tcx.hir().expect_trait_item_by_hir_id(trait_c_hir_id).node {
TraitItemKind::Const(ref ty, _) => ty.span,
_ => bug!("{:?} is not a trait const", trait_c),
}

13
src/librustc_typeck/check/mod.rs
View file

@ -593,8 +593,7 @@ impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
-> InheritedBuilder<'a, 'gcx, 'tcx> {
let hir_id_root = if def_id.is_local() {
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = tcx.hir().definitions().node_to_hir_id(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
DefId::local(hir_id.owner)
} else {
def_id
@ -619,8 +618,8 @@ impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
let tcx = infcx.tcx;
let item_id = tcx.hir().as_local_node_id(def_id);
let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
let item_id = tcx.hir().as_local_hir_id(def_id);
let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by_by_hir_id(id));
let implicit_region_bound = body_id.map(|body_id| {
let body = tcx.hir().body(body_id);
tcx.mk_region(ty::ReScope(region::Scope {
@ -1920,9 +1919,9 @@ impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
-> Lrc<ty::GenericPredicates<'tcx>>
{
let tcx = self.tcx;
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let item_id = tcx.hir().ty_param_owner(node_id);
let item_def_id = tcx.hir().local_def_id(item_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let item_id = tcx.hir().ty_param_owner(hir_id);
let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
let generics = tcx.generics_of(item_def_id);
let index = generics.param_def_id_to_index[&def_id];
Lrc::new(ty::GenericPredicates {

12
src/librustc_typeck/check/upvar.rs
View file

@ -120,9 +120,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
None
};
let closure_node_id = self.tcx.hir().hir_to_node_id(closure_hir_id);
self.tcx.with_freevars(closure_node_id, |freevars| {
self.tcx.with_freevars(closure_hir_id, |freevars| {
let mut freevar_list: Vec<ty::UpvarId> = Vec::with_capacity(freevars.len());
for freevar in freevars {
let upvar_id = ty::UpvarId {
@ -217,10 +215,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// inference algorithm will reject it).
// Equate the type variables for the upvars with the actual types.
let final_upvar_tys = self.final_upvar_tys(closure_node_id);
let final_upvar_tys = self.final_upvar_tys(closure_hir_id);
debug!(
"analyze_closure: id={:?} substs={:?} final_upvar_tys={:?}",
closure_node_id, substs, final_upvar_tys
closure_hir_id, substs, final_upvar_tys
);
for (upvar_ty, final_upvar_ty) in substs
.upvar_tys(closure_def_id, self.tcx)
@ -238,14 +236,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
}
// Returns a list of `ClosureUpvar`s for each upvar.
fn final_upvar_tys(&self, closure_id: ast::NodeId) -> Vec<Ty<'tcx>> {
fn final_upvar_tys(&self, closure_id: hir::HirId) -> Vec<Ty<'tcx>> {
// Presently an unboxed closure type cannot "escape" out of a
// function, so we will only encounter ones that originated in the
// local crate or were inlined into it along with some function.
// This may change if abstract return types of some sort are
// implemented.
let tcx = self.tcx;
let closure_def_index = tcx.hir().local_def_id(closure_id);
let closure_def_index = tcx.hir().local_def_id_from_hir_id(closure_id);
tcx.with_freevars(closure_id, |freevars| {
freevars

12
src/librustc_typeck/check/wfcheck.rs
View file

@ -151,8 +151,8 @@ pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: Def
}
pub fn check_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let trait_item = tcx.hir().expect_trait_item(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let trait_item = tcx.hir().expect_trait_item_by_hir_id(hir_id);
let method_sig = match trait_item.node {
hir::TraitItemKind::Method(ref sig, _) => Some(sig),
@ -162,8 +162,8 @@ pub fn check_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
}
pub fn check_impl_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let impl_item = tcx.hir().expect_impl_item(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let impl_item = tcx.hir().expect_impl_item_by_hir_id(hir_id);
let method_sig = match impl_item.node {
hir::ImplItemKind::Method(ref sig, _) => Some(sig),
@ -625,8 +625,8 @@ fn check_existential_types<'a, 'fcx, 'gcx, 'tcx>(
let generics = tcx.generics_of(def_id);
// only check named existential types defined in this crate
if generics.parent.is_none() && def_id.is_local() {
let opaque_node_id = tcx.hir().as_local_node_id(def_id).unwrap();
if may_define_existential_type(tcx, fn_def_id, opaque_node_id) {
let opaque_hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
if may_define_existential_type(tcx, fn_def_id, opaque_hir_id) {
trace!("check_existential_types may define. Generics: {:#?}", generics);
let mut seen: FxHashMap<_, Vec<_>> = FxHashMap::default();
for (subst, param) in substs.iter().zip(&generics.params) {

4
src/librustc_typeck/check_unused.rs
View file

@ -94,8 +94,8 @@ fn unused_crates_lint<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) {
// Note that if we carry through to the `extern_mod_stmt_cnum` query
// below it'll cause a panic because `def_id` is actually bogus at this
// point in time otherwise.
if let Some(id) = tcx.hir().as_local_node_id(def_id) {
if tcx.hir().find(id).is_none() {
if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
if tcx.hir().find_by_hir_id(id).is_none() {
return false;
}
}

4
src/librustc_typeck/coherence/builtin.rs
View file

@ -50,8 +50,8 @@ fn visit_implementation_of_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did:
/* do nothing */
} else {
// Destructors only work on nominal types.
if let Some(impl_node_id) = tcx.hir().as_local_node_id(impl_did) {
if let Some(Node::Item(item)) = tcx.hir().find(impl_node_id) {
if let Some(impl_hir_id) = tcx.hir().as_local_hir_id(impl_did) {
if let Some(Node::Item(item)) = tcx.hir().find_by_hir_id(impl_hir_id) {
let span = match item.node {
ItemKind::Impl(.., ref ty, _) => ty.span,
_ => item.span,

56
src/librustc_typeck/collect.rs
View file

@ -255,9 +255,9 @@ fn type_param_predicates<'a, 'tcx>(
// written inline like `<T : Foo>` or in a where clause like
// `where T : Foo`.
let param_id = tcx.hir().as_local_node_id(def_id).unwrap();
let param_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let param_owner = tcx.hir().ty_param_owner(param_id);
let param_owner_def_id = tcx.hir().local_def_id(param_owner);
let param_owner_def_id = tcx.hir().local_def_id_from_hir_id(param_owner);
let generics = tcx.generics_of(param_owner_def_id);
let index = generics.param_def_id_to_index[&def_id];
let ty = tcx.mk_ty_param(index, tcx.hir().ty_param_name(param_id).as_interned_str());
@ -280,8 +280,8 @@ fn type_param_predicates<'a, 'tcx>(
},
);
let item_node_id = tcx.hir().as_local_node_id(item_def_id).unwrap();
let ast_generics = match tcx.hir().get(item_node_id) {
let item_hir_id = tcx.hir().as_local_hir_id(item_def_id).unwrap();
let ast_generics = match tcx.hir().get_by_hir_id(item_hir_id) {
Node::TraitItem(item) => &item.generics,
Node::ImplItem(item) => &item.generics,
@ -301,7 +301,7 @@ fn type_param_predicates<'a, 'tcx>(
| ItemKind::Union(_, ref generics) => generics,
ItemKind::Trait(_, _, ref generics, ..) => {
// Implied `Self: Trait` and supertrait bounds.
if param_id == item_node_id {
if param_id == item_hir_id {
let identity_trait_ref = ty::TraitRef::identity(tcx, item_def_id);
Lrc::make_mut(&mut result)
.predicates
@ -322,10 +322,9 @@ fn type_param_predicates<'a, 'tcx>(
};
let icx = ItemCtxt::new(tcx, item_def_id);
let param_hir_id = tcx.hir().node_to_hir_id(param_id);
Lrc::make_mut(&mut result)
.predicates
.extend(icx.type_parameter_bounds_in_generics(ast_generics, param_hir_id, ty,
.extend(icx.type_parameter_bounds_in_generics(ast_generics, param_id, ty,
OnlySelfBounds(true)));
result
}
@ -619,8 +618,8 @@ fn convert_variant<'a, 'tcx>(
fn adt_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::AdtDef {
use rustc::hir::*;
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let item = match tcx.hir().get(node_id) {
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let item = match tcx.hir().get_by_hir_id(hir_id) {
Node::Item(item) => item,
_ => bug!(),
};
@ -694,11 +693,11 @@ fn super_predicates_of<'a, 'tcx>(
trait_def_id: DefId,
) -> Lrc<ty::GenericPredicates<'tcx>> {
debug!("super_predicates(trait_def_id={:?})", trait_def_id);
let trait_node_id = tcx.hir().as_local_node_id(trait_def_id).unwrap();
let trait_hir_id = tcx.hir().as_local_hir_id(trait_def_id).unwrap();
let item = match tcx.hir().get(trait_node_id) {
let item = match tcx.hir().get_by_hir_id(trait_hir_id) {
Node::Item(item) => item,
_ => bug!("trait_node_id {} is not an item", trait_node_id),
_ => bug!("trait_node_id {} is not an item", trait_hir_id),
};
let (generics, bounds) = match item.node {
@ -887,14 +886,14 @@ fn has_late_bound_regions<'a, 'tcx>(
fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::Generics {
use rustc::hir::*;
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let node = tcx.hir().get(node_id);
let node = tcx.hir().get_by_hir_id(hir_id);
let parent_def_id = match node {
Node::ImplItem(_) | Node::TraitItem(_) | Node::Variant(_)
| Node::StructCtor(_) | Node::Field(_) => {
let parent_id = tcx.hir().get_parent(node_id);
Some(tcx.hir().local_def_id(parent_id))
let parent_id = tcx.hir().get_parent_item(hir_id);
Some(tcx.hir().local_def_id_from_hir_id(parent_id))
}
Node::Expr(&hir::Expr {
node: hir::ExprKind::Closure(..),
@ -994,7 +993,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
}),
);
let hir_id = tcx.hir().node_to_hir_id(node_id);
let object_lifetime_defaults = tcx.object_lifetime_defaults(hir_id);
// Now create the real type parameters.
@ -1096,7 +1094,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty
}),
);
tcx.with_freevars(node_id, |fv| {
tcx.with_freevars(hir_id, |fv| {
params.extend(fv.iter().zip((dummy_args.len() as u32)..).map(|(_, i)| {
ty::GenericParamDef {
index: type_start + i,
@ -1569,16 +1567,16 @@ fn find_existential_constraints<'a, 'tcx>(
tcx,
found: None,
};
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let parent = tcx.hir().get_parent(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let parent = tcx.hir().get_parent_item(hir_id);
trace!("parent_id: {:?}", parent);
if parent == ast::CRATE_NODE_ID {
if parent == hir::CRATE_HIR_ID {
intravisit::walk_crate(&mut locator, tcx.hir().krate());
} else {
trace!("parent: {:?}", tcx.hir().get(parent));
match tcx.hir().get(parent) {
trace!("parent: {:?}", tcx.hir().get_by_hir_id(parent));
match tcx.hir().get_by_hir_id(parent) {
Node::Item(ref it) => intravisit::walk_item(&mut locator, it),
Node::ImplItem(ref it) => intravisit::walk_impl_item(&mut locator, it),
Node::TraitItem(ref it) => intravisit::walk_trait_item(&mut locator, it),
@ -1603,11 +1601,11 @@ fn fn_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ty::PolyFnSig
use rustc::hir::*;
use rustc::hir::Node::*;
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let icx = ItemCtxt::new(tcx, def_id);
match tcx.hir().get(node_id) {
match tcx.hir().get_by_hir_id(hir_id) {
TraitItem(hir::TraitItem {
node: TraitItemKind::Method(sig, _),
..
@ -1626,7 +1624,7 @@ fn fn_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ty::PolyFnSig
node: ForeignItemKind::Fn(ref fn_decl, _, _),
..
}) => {
let abi = tcx.hir().get_foreign_abi(node_id);
let abi = tcx.hir().get_foreign_abi_by_hir_id(hir_id);
compute_sig_of_foreign_fn_decl(tcx, def_id, fn_decl, abi)
}
@ -1639,7 +1637,7 @@ fn fn_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ty::PolyFnSig
},
..
}) => {
let ty = tcx.type_of(tcx.hir().get_parent_did(node_id));
let ty = tcx.type_of(tcx.hir().get_parent_did_by_hir_id(hir_id));
let inputs = fields
.iter()
.map(|f| tcx.type_of(tcx.hir().local_def_id_from_hir_id(f.hir_id)));
@ -1878,8 +1876,8 @@ fn explicit_predicates_of<'a, 'tcx>(
}
}
let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
let node = tcx.hir().get(node_id);
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let node = tcx.hir().get_by_hir_id(hir_id);
let mut is_trait = None;
let mut is_default_impl_trait = None;

4
src/librustc_typeck/outlives/mod.rs
View file

@ -26,10 +26,10 @@ fn inferred_outlives_of<'a, 'tcx>(
) -> Lrc<Vec<ty::Predicate<'tcx>>> {
let id = tcx
.hir()
.as_local_node_id(item_def_id)
.as_local_hir_id(item_def_id)
.expect("expected local def-id");
match tcx.hir().get(id) {
match tcx.hir().get_by_hir_id(id) {
Node::Item(item) => match item.node {
hir::ItemKind::Struct(..) | hir::ItemKind::Enum(..) | hir::ItemKind::Union(..) => {
let crate_map = tcx.inferred_outlives_crate(LOCAL_CRATE);

8
src/librustdoc/clean/auto_trait.rs
View file

@ -3,7 +3,7 @@ use rustc::traits::auto_trait as auto;
use rustc::ty::{self, TypeFoldable};
use std::fmt::Debug;
use self::def_ctor::{get_def_from_def_id, get_def_from_node_id};
use self::def_ctor::{get_def_from_def_id, get_def_from_hir_id};
use super::*;
@ -25,9 +25,9 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
})
}
pub fn get_with_node_id(&self, id: ast::NodeId, name: String) -> Vec<Item> {
get_def_from_node_id(&self.cx, id, name, &|def_ctor, name| {
let did = self.cx.tcx.hir().local_def_id(id);
pub fn get_with_hir_id(&self, id: hir::HirId, name: String) -> Vec<Item> {
get_def_from_hir_id(&self.cx, id, name, &|def_ctor, name| {
let did = self.cx.tcx.hir().local_def_id_from_hir_id(id);
self.get_auto_trait_impls(did, &def_ctor, Some(name))
})
}

8
src/librustdoc/clean/blanket_impl.rs
View file

@ -9,7 +9,7 @@ use crate::core::DocAccessLevels;
use super::*;
use self::def_ctor::{get_def_from_def_id, get_def_from_node_id};
use self::def_ctor::{get_def_from_def_id, get_def_from_hir_id};
pub struct BlanketImplFinder<'a, 'tcx: 'a, 'rcx: 'a> {
pub cx: &'a core::DocContext<'a, 'tcx, 'rcx>,
@ -26,9 +26,9 @@ impl<'a, 'tcx, 'rcx> BlanketImplFinder <'a, 'tcx, 'rcx> {
})
}
pub fn get_with_node_id(&self, id: ast::NodeId, name: String) -> Vec<Item> {
get_def_from_node_id(&self.cx, id, name, &|def_ctor, name| {
let did = self.cx.tcx.hir().local_def_id(id);
pub fn get_with_hir_id(&self, id: hir::HirId, name: String) -> Vec<Item> {
get_def_from_hir_id(&self.cx, id, name, &|def_ctor, name| {
let did = self.cx.tcx.hir().local_def_id_from_hir_id(id);
self.get_blanket_impls(did, &def_ctor, Some(name))
})
}

10
src/librustdoc/clean/def_ctor.rs
View file

@ -38,13 +38,13 @@ where F: Fn(& dyn Fn(DefId) -> Def) -> Vec<Item> {
}
}
pub fn get_def_from_node_id<F>(cx: &DocContext<'_, '_, '_>,
id: ast::NodeId,
name: String,
callback: &F,
pub fn get_def_from_hir_id<F>(cx: &DocContext<'_, '_, '_>,
id: hir::HirId,
name: String,
callback: &F,
) -> Vec<Item>
where F: Fn(& dyn Fn(DefId) -> Def, String) -> Vec<Item> {
let item = &cx.tcx.hir().expect_item(id).node;
let item = &cx.tcx.hir().expect_item_by_hir_id(id).node;
callback(&match *item {
hir::ItemKind::Struct(_, _) => Def::Struct,

4
src/librustdoc/clean/inline.rs
View file

@ -422,8 +422,8 @@ fn build_module(
}
pub fn print_inlined_const(cx: &DocContext<'_, '_, '_>, did: DefId) -> String {
if let Some(node_id) = cx.tcx.hir().as_local_node_id(did) {
cx.tcx.hir().node_to_pretty_string(node_id)
if let Some(node_id) = cx.tcx.hir().as_local_hir_id(did) {
cx.tcx.hir().hir_to_pretty_string(node_id)
} else {
cx.tcx.rendered_const(did)
}

18
src/librustdoc/clean/mod.rs
View file

@ -1847,7 +1847,7 @@ impl<'a, A: Copy> Clean<FnDecl> for (&'a hir::FnDecl, A)
impl<'a, 'tcx> Clean<FnDecl> for (DefId, ty::PolyFnSig<'tcx>) {
fn clean(&self, cx: &DocContext<'_, '_, '_>) -> FnDecl {
let (did, sig) = *self;
let mut names = if cx.tcx.hir().as_local_node_id(did).is_some() {
let mut names = if cx.tcx.hir().as_local_hir_id(did).is_some() {
vec![].into_iter()
} else {
cx.tcx.fn_arg_names(did).into_iter()
@ -3541,13 +3541,13 @@ pub struct Impl {
pub blanket_impl: Option<Type>,
}
pub fn get_auto_traits_with_node_id(
pub fn get_auto_traits_with_hir_id(
cx: &DocContext<'_, '_, '_>,
id: ast::NodeId,
id: hir::HirId,
name: String
) -> Vec<Item> {
let finder = AutoTraitFinder::new(cx);
finder.get_with_node_id(id, name)
finder.get_with_hir_id(id, name)
}
pub fn get_auto_traits_with_def_id(
@ -3559,13 +3559,13 @@ pub fn get_auto_traits_with_def_id(
finder.get_with_def_id(id)
}
pub fn get_blanket_impls_with_node_id(
pub fn get_blanket_impls_with_hir_id(
cx: &DocContext<'_, '_, '_>,
id: ast::NodeId,
id: hir::HirId,
name: String
) -> Vec<Item> {
let finder = BlanketImplFinder::new(cx);
finder.get_with_node_id(id, name)
finder.get_with_hir_id(id, name)
}
pub fn get_blanket_impls_with_def_id(
@ -3902,8 +3902,8 @@ fn name_from_pat(p: &hir::Pat) -> String {
fn print_const(cx: &DocContext<'_, '_, '_>, n: ty::LazyConst<'_>) -> String {
match n {
ty::LazyConst::Unevaluated(def_id, _) => {
if let Some(node_id) = cx.tcx.hir().as_local_node_id(def_id) {
print_const_expr(cx, cx.tcx.hir().body_owned_by(node_id))
if let Some(hir_id) = cx.tcx.hir().as_local_hir_id(def_id) {
print_const_expr(cx, cx.tcx.hir().body_owned_by(hir_id))
} else {
inline::print_inlined_const(cx, def_id)
}

15
src/librustdoc/core.rs
View file

@ -3,7 +3,7 @@ use rustc_driver::{driver, abort_on_err};
use rustc::session::{self, config};
use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CrateNum, LOCAL_CRATE};
use rustc::hir::def::Def;
use rustc::hir::{self, HirVec};
use rustc::hir::{self, HirId, HirVec};
use rustc::middle::cstore::CrateStore;
use rustc::middle::privacy::AccessLevels;
use rustc::ty::{self, TyCtxt, AllArenas};
@ -17,7 +17,7 @@ use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::CStore;
use rustc_target::spec::TargetTriple;
use syntax::ast::{self, Ident, NodeId};
use syntax::ast::{self, Ident};
use syntax::source_map;
use syntax::feature_gate::UnstableFeatures;
use syntax::json::JsonEmitter;
@ -159,7 +159,7 @@ impl<'a, 'tcx, 'rcx> DocContext<'a, 'tcx, 'rcx> {
/// Like the function of the same name on the HIR map, but skips calling it on fake DefIds.
/// (This avoids a slice-index-out-of-bounds panic.)
pub fn as_local_node_id(&self, def_id: DefId) -> Option<NodeId> {
pub fn as_local_node_id(&self, def_id: DefId) -> Option<ast::NodeId> {
if self.all_fake_def_ids.borrow().contains(&def_id) {
None
} else {
@ -167,6 +167,15 @@ impl<'a, 'tcx, 'rcx> DocContext<'a, 'tcx, 'rcx> {
}
}
// FIXME(@ljedrz): remove the NodeId variant
pub fn as_local_hir_id(&self, def_id: DefId) -> Option<HirId> {
if self.all_fake_def_ids.borrow().contains(&def_id) {
None
} else {
self.tcx.hir().as_local_hir_id(def_id)
}
}
pub fn get_real_ty<F>(&self,
def_id: DefId,
def_ctor: &F,

18
src/librustdoc/passes/collect_intra_doc_links.rs
View file

@ -4,7 +4,7 @@ use rustc::hir::def::Def;
use rustc::hir::def_id::DefId;
use rustc::ty;
use syntax;
use syntax::ast::{self, Ident, NodeId};
use syntax::ast::{self, Ident};
use syntax::feature_gate::UnstableFeatures;
use syntax::symbol::Symbol;
use syntax_pos::DUMMY_SP;
@ -49,7 +49,7 @@ enum PathKind {
struct LinkCollector<'a, 'tcx: 'a, 'rcx: 'a> {
cx: &'a DocContext<'a, 'tcx, 'rcx>,
mod_ids: Vec<NodeId>,
mod_ids: Vec<ast::NodeId>,
is_nightly_build: bool,
}
@ -69,7 +69,7 @@ impl<'a, 'tcx, 'rcx> LinkCollector<'a, 'tcx, 'rcx> {
path_str: &str,
is_val: bool,
current_item: &Option<String>,
parent_id: Option<NodeId>)
parent_id: Option<ast::NodeId>)
-> Result<(Def, Option<String>), ()>
{
let cx = self.cx;
@ -220,8 +220,8 @@ impl<'a, 'tcx, 'rcx> LinkCollector<'a, 'tcx, 'rcx> {
impl<'a, 'tcx, 'rcx> DocFolder for LinkCollector<'a, 'tcx, 'rcx> {
fn fold_item(&mut self, mut item: Item) -> Option<Item> {
let item_node_id = if item.is_mod() {
if let Some(id) = self.cx.tcx.hir().as_local_node_id(item.def_id) {
let item_hir_id = if item.is_mod() {
if let Some(id) = self.cx.tcx.hir().as_local_hir_id(item.def_id) {
Some(id)
} else {
debug!("attempting to fold on a non-local item: {:?}", item);
@ -248,14 +248,14 @@ impl<'a, 'tcx, 'rcx> DocFolder for LinkCollector<'a, 'tcx, 'rcx> {
let current_item = match item.inner {
ModuleItem(..) => {
if item.attrs.inner_docs {
if item_node_id.unwrap() != NodeId::from_u32(0) {
if item_hir_id.unwrap() != hir::CRATE_HIR_ID {
item.name.clone()
} else {
None
}
} else {
match parent_node.or(self.mod_ids.last().cloned()) {
Some(parent) if parent != NodeId::from_u32(0) => {
Some(parent) if parent != ast::CRATE_NODE_ID => {
// FIXME: can we pull the parent module's name from elsewhere?
Some(self.cx.tcx.hir().name(parent).to_string())
}
@ -274,7 +274,7 @@ impl<'a, 'tcx, 'rcx> DocFolder for LinkCollector<'a, 'tcx, 'rcx> {
};
if item.is_mod() && item.attrs.inner_docs {
self.mod_ids.push(item_node_id.unwrap());
self.mod_ids.push(self.cx.tcx.hir().hir_to_node_id(item_hir_id.unwrap()));
}
let cx = self.cx;
@ -421,7 +421,7 @@ impl<'a, 'tcx, 'rcx> DocFolder for LinkCollector<'a, 'tcx, 'rcx> {
}
if item.is_mod() && !item.attrs.inner_docs {
self.mod_ids.push(item_node_id.unwrap());
self.mod_ids.push(self.cx.tcx.hir().hir_to_node_id(item_hir_id.unwrap()));
}
if item.is_mod() {

8
src/librustdoc/passes/collect_trait_impls.rs
View file

@ -155,11 +155,11 @@ impl<'a, 'tcx, 'rcx> SyntheticImplCollector<'a, 'tcx, 'rcx> {
impl<'a, 'tcx, 'rcx> DocFolder for SyntheticImplCollector<'a, 'tcx, 'rcx> {
fn fold_item(&mut self, i: Item) -> Option<Item> {
if i.is_struct() || i.is_enum() || i.is_union() {
if let (Some(node_id), Some(name)) =
(self.cx.tcx.hir().as_local_node_id(i.def_id), i.name.clone())
if let (Some(hir_id), Some(name)) =
(self.cx.tcx.hir().as_local_hir_id(i.def_id), i.name.clone())
{
self.impls.extend(get_auto_traits_with_node_id(self.cx, node_id, name.clone()));
self.impls.extend(get_blanket_impls_with_node_id(self.cx, node_id, name));
self.impls.extend(get_auto_traits_with_hir_id(self.cx, hir_id, name.clone()));
self.impls.extend(get_blanket_impls_with_hir_id(self.cx, hir_id, name));
} else {
self.impls.extend(get_auto_traits_with_def_id(self.cx, i.def_id));
self.impls.extend(get_blanket_impls_with_def_id(self.cx, i.def_id));

2
src/librustdoc/passes/mod.rs
View file

@ -291,7 +291,7 @@ pub fn look_for_tests<'a, 'tcx: 'a, 'rcx: 'a>(
item: &Item,
check_missing_code: bool,
) {
if cx.as_local_node_id(item.def_id).is_none() {
if cx.as_local_hir_id(item.def_id).is_none() {
// If non-local, no need to check anything.
return;
}

2
src/test/mir-opt/inline-closure-borrows-arg.rs
View file

@ -20,7 +20,7 @@ fn foo<T: Copy>(_t: T, q: &i32) -> i32 {
// ...
// bb0: {
// ...
// _3 = [closure@NodeId(53)];
// _3 = [closure@HirId { owner: DefIndex(0:4), local_id: 27 }];
// ...
// _4 = &_3;
// ...

2
src/test/mir-opt/inline-closure.rs
View file

@ -16,7 +16,7 @@ fn foo<T: Copy>(_t: T, q: i32) -> i32 {
// ...
// bb0: {
// ...
// _3 = [closure@NodeId(39)];
// _3 = [closure@HirId { owner: DefIndex(0:4), local_id: 11 }];
// ...
// _4 = &_3;
// ...

2
src/test/mir-opt/retag.rs
View file

@ -98,7 +98,7 @@ fn main() {
// }
// END rustc.main.EraseRegions.after.mir
// START rustc.main-{{closure}}.EraseRegions.after.mir
// fn main::{{closure}}(_1: &[closure@NodeId(124)], _2: &i32) -> &i32 {
// fn main::{{closure}}(_1: &[closure@HirId { owner: DefIndex(0:7), local_id: 70 }], _2: &i32) -> &i32 {
// ...
// bb0: {
// Retag([fn entry] _1);