Skip to content

Commit befc4b1

Browse files
varkorvarkor
committed
Rename hir::map::Node to hir::map::NodeKind
1 parent a1a338f commit befc4b1

File tree

47 files changed

+457
-457
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

47 files changed

+457
-457
lines changed

‎src/librustc/hir/map/blocks.rs

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
//! for the `Code` associated with a particular NodeId.
2323
2424
use hir as ast;
25-
use hir::map::{self, Node};
25+
use hir::map::{self, NodeKind};
2626
use hir::{Expr, FnDecl};
2727
use hir::intravisit::FnKind;
2828
use syntax::ast::{Attribute, Ident, Name, NodeId};
@@ -39,7 +39,7 @@ use syntax_pos::Span;
3939
///
4040
/// To construct one, use the `Code::from_node` function.
4141
#[derive(Copy, Clone, Debug)]
42-
pub struct FnLikeNode<'a> { node: map::Node<'a> }
42+
pub struct FnLikeNode<'a> { node: NodeKind<'a> }
4343

4444
/// MaybeFnLike wraps a method that indicates if an object
4545
/// corresponds to some FnLikeNode.
@@ -95,11 +95,11 @@ impl<'a> Code<'a> {
9595
/// Attempts to construct a Code from presumed FnLike or Expr node input.
9696
pub fn from_node(map: &map::Map<'a>, id: NodeId) -> Option<Code<'a>> {
9797
match map.get(id) {
98-
map::NodeBlock(_) => {
98+
map::NodeKind::Block(_) => {
9999
// Use the parent, hopefully an expression node.
100100
Code::from_node(map, map.get_parent_node(id))
101101
}
102-
map::NodeExpr(expr) => Some(Code::Expr(expr)),
102+
map::NodeKind::Expr(expr) => Some(Code::Expr(expr)),
103103
node => FnLikeNode::from_node(node).map(Code::FnLike)
104104
}
105105
}
@@ -143,12 +143,12 @@ impl<'a> ClosureParts<'a> {
143143

144144
impl<'a> FnLikeNode<'a> {
145145
/// Attempts to construct a FnLikeNode from presumed FnLike node input.
146-
pub fn from_node(node: Node) -> Option<FnLikeNode> {
146+
pub fn from_node(node: NodeKind) -> Option<FnLikeNode> {
147147
let fn_like = match node {
148-
map::NodeItem(item) => item.is_fn_like(),
149-
map::NodeTraitItem(tm) => tm.is_fn_like(),
150-
map::NodeImplItem(it) => it.is_fn_like(),
151-
map::NodeExpr(e) => e.is_fn_like(),
148+
map::NodeKind::Item(item) => item.is_fn_like(),
149+
map::NodeKind::TraitItem(tm) => tm.is_fn_like(),
150+
map::NodeKind::ImplItem(it) => it.is_fn_like(),
151+
map::NodeKind::Expr(e) => e.is_fn_like(),
152152
_ => false
153153
};
154154
if fn_like {
@@ -234,7 +234,7 @@ impl<'a> FnLikeNode<'a> {
234234
C: FnOnce(ClosureParts<'a>) -> A,
235235
{
236236
match self.node {
237-
map::NodeItem(i) => match i.node {
237+
map::NodeKind::Item(i) => match i.node {
238238
ast::ItemKind::Fn(ref decl, header, ref generics, block) =>
239239
item_fn(ItemFnParts {
240240
id: i.id,
@@ -249,13 +249,13 @@ impl<'a> FnLikeNode<'a> {
249249
}),
250250
_ => bug!("item FnLikeNode that is not fn-like"),
251251
},
252-
map::NodeTraitItem(ti) => match ti.node {
252+
map::NodeKind::TraitItem(ti) => match ti.node {
253253
ast::TraitItemKind::Method(ref sig, ast::TraitMethod::Provided(body)) => {
254254
method(ti.id, ti.ident, sig, None, body, ti.span, &ti.attrs)
255255
}
256256
_ => bug!("trait method FnLikeNode that is not fn-like"),
257257
},
258-
map::NodeImplItem(ii) => {
258+
map::NodeKind::ImplItem(ii) => {
259259
match ii.node {
260260
ast::ImplItemKind::Method(ref sig, body) => {
261261
method(ii.id, ii.ident, sig, Some(&ii.vis), body, ii.span, &ii.attrs)
@@ -265,7 +265,7 @@ impl<'a> FnLikeNode<'a> {
265265
}
266266
}
267267
},
268-
map::NodeExpr(e) => match e.node {
268+
map::NodeKind::Expr(e) => match e.node {
269269
ast::ExprKind::Closure(_, ref decl, block, _fn_decl_span, _gen) =>
270270
closure(ClosureParts::new(&decl, block, e.id, e.span, &e.attrs)),
271271
_ => bug!("expr FnLikeNode that is not fn-like"),

‎src/librustc/hir/map/collector.rs

Lines changed: 41 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -187,7 +187,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
187187
self.map[id.as_usize()] = entry;
188188
}
189189

190-
fn insert(&mut self, id: NodeId, node: Node<'hir>) {
190+
fn insert(&mut self, id: NodeId, node: NodeKind<'hir>) {
191191
let parent = self.parent_node;
192192
let dep_node_index = if self.currently_in_body {
193193
self.current_full_dep_index
@@ -196,26 +196,26 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
196196
};
197197

198198
let entry = match node {
199-
NodeItem(n) => EntryKind::Item(parent, dep_node_index, n),
200-
NodeForeignItem(n) => EntryKind::ForeignItem(parent, dep_node_index, n),
201-
NodeTraitItem(n) => EntryKind::TraitItem(parent, dep_node_index, n),
202-
NodeImplItem(n) => EntryKind::ImplItem(parent, dep_node_index, n),
203-
NodeVariant(n) => EntryKind::Variant(parent, dep_node_index, n),
204-
NodeField(n) => EntryKind::Field(parent, dep_node_index, n),
205-
NodeAnonConst(n) => EntryKind::AnonConst(parent, dep_node_index, n),
206-
NodeExpr(n) => EntryKind::Expr(parent, dep_node_index, n),
207-
NodeStmt(n) => EntryKind::Stmt(parent, dep_node_index, n),
208-
NodeTy(n) => EntryKind::Ty(parent, dep_node_index, n),
209-
NodeTraitRef(n) => EntryKind::TraitRef(parent, dep_node_index, n),
210-
NodeBinding(n) => EntryKind::Binding(parent, dep_node_index, n),
211-
NodePat(n) => EntryKind::Pat(parent, dep_node_index, n),
212-
NodeBlock(n) => EntryKind::Block(parent, dep_node_index, n),
213-
NodeStructCtor(n) => EntryKind::StructCtor(parent, dep_node_index, n),
214-
NodeLifetime(n) => EntryKind::Lifetime(parent, dep_node_index, n),
215-
NodeGenericParam(n) => EntryKind::GenericParam(parent, dep_node_index, n),
216-
NodeVisibility(n) => EntryKind::Visibility(parent, dep_node_index, n),
217-
NodeLocal(n) => EntryKind::Local(parent, dep_node_index, n),
218-
NodeMacroDef(n) => EntryKind::MacroDef(dep_node_index, n),
199+
NodeKind::Item(n) => EntryKind::Item(parent, dep_node_index, n),
200+
NodeKind::ForeignItem(n) => EntryKind::ForeignItem(parent, dep_node_index, n),
201+
NodeKind::TraitItem(n) => EntryKind::TraitItem(parent, dep_node_index, n),
202+
NodeKind::ImplItem(n) => EntryKind::ImplItem(parent, dep_node_index, n),
203+
NodeKind::Variant(n) => EntryKind::Variant(parent, dep_node_index, n),
204+
NodeKind::Field(n) => EntryKind::Field(parent, dep_node_index, n),
205+
NodeKind::AnonConst(n) => EntryKind::AnonConst(parent, dep_node_index, n),
206+
NodeKind::Expr(n) => EntryKind::Expr(parent, dep_node_index, n),
207+
NodeKind::Stmt(n) => EntryKind::Stmt(parent, dep_node_index, n),
208+
NodeKind::Ty(n) => EntryKind::Ty(parent, dep_node_index, n),
209+
NodeKind::TraitRef(n) => EntryKind::TraitRef(parent, dep_node_index, n),
210+
NodeKind::Binding(n) => EntryKind::Binding(parent, dep_node_index, n),
211+
NodeKind::Pat(n) => EntryKind::Pat(parent, dep_node_index, n),
212+
NodeKind::Block(n) => EntryKind::Block(parent, dep_node_index, n),
213+
NodeKind::StructCtor(n) => EntryKind::StructCtor(parent, dep_node_index, n),
214+
NodeKind::Lifetime(n) => EntryKind::Lifetime(parent, dep_node_index, n),
215+
NodeKind::GenericParam(n) => EntryKind::GenericParam(parent, dep_node_index, n),
216+
NodeKind::Visibility(n) => EntryKind::Visibility(parent, dep_node_index, n),
217+
NodeKind::Local(n) => EntryKind::Local(parent, dep_node_index, n),
218+
NodeKind::MacroDef(n) => EntryKind::MacroDef(dep_node_index, n),
219219
};
220220

221221
// Make sure that the DepNode of some node coincides with the HirId
@@ -326,13 +326,13 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
326326
debug_assert_eq!(i.hir_id.owner,
327327
self.definitions.opt_def_index(i.id).unwrap());
328328
self.with_dep_node_owner(i.hir_id.owner, i, |this| {
329-
this.insert(i.id, NodeItem(i));
329+
this.insert(i.id, NodeKind::Item(i));
330330
this.with_parent(i.id, |this| {
331331
match i.node {
332332
ItemKind::Struct(ref struct_def, _) => {
333333
// If this is a tuple-like struct, register the constructor.
334334
if !struct_def.is_struct() {
335-
this.insert(struct_def.id(), NodeStructCtor(struct_def));
335+
this.insert(struct_def.id(), NodeKind::StructCtor(struct_def));
336336
}
337337
}
338338
_ => {}
@@ -343,23 +343,23 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
343343
}
344344

345345
fn visit_foreign_item(&mut self, foreign_item: &'hir ForeignItem) {
346-
self.insert(foreign_item.id, NodeForeignItem(foreign_item));
346+
self.insert(foreign_item.id, NodeKind::ForeignItem(foreign_item));
347347

348348
self.with_parent(foreign_item.id, |this| {
349349
intravisit::walk_foreign_item(this, foreign_item);
350350
});
351351
}
352352

353353
fn visit_generic_param(&mut self, param: &'hir GenericParam) {
354-
self.insert(param.id, NodeGenericParam(param));
354+
self.insert(param.id, NodeKind::GenericParam(param));
355355
intravisit::walk_generic_param(self, param);
356356
}
357357

358358
fn visit_trait_item(&mut self, ti: &'hir TraitItem) {
359359
debug_assert_eq!(ti.hir_id.owner,
360360
self.definitions.opt_def_index(ti.id).unwrap());
361361
self.with_dep_node_owner(ti.hir_id.owner, ti, |this| {
362-
this.insert(ti.id, NodeTraitItem(ti));
362+
this.insert(ti.id, NodeKind::TraitItem(ti));
363363

364364
this.with_parent(ti.id, |this| {
365365
intravisit::walk_trait_item(this, ti);
@@ -371,7 +371,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
371371
debug_assert_eq!(ii.hir_id.owner,
372372
self.definitions.opt_def_index(ii.id).unwrap());
373373
self.with_dep_node_owner(ii.hir_id.owner, ii, |this| {
374-
this.insert(ii.id, NodeImplItem(ii));
374+
this.insert(ii.id, NodeKind::ImplItem(ii));
375375

376376
this.with_parent(ii.id, |this| {
377377
intravisit::walk_impl_item(this, ii);
@@ -381,9 +381,9 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
381381

382382
fn visit_pat(&mut self, pat: &'hir Pat) {
383383
let node = if let PatKind::Binding(..) = pat.node {
384-
NodeBinding(pat)
384+
NodeKind::Binding(pat)
385385
} else {
386-
NodePat(pat)
386+
NodeKind::Pat(pat)
387387
};
388388
self.insert(pat.id, node);
389389

@@ -393,15 +393,15 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
393393
}
394394

395395
fn visit_anon_const(&mut self, constant: &'hir AnonConst) {
396-
self.insert(constant.id, NodeAnonConst(constant));
396+
self.insert(constant.id, NodeKind::AnonConst(constant));
397397

398398
self.with_parent(constant.id, |this| {
399399
intravisit::walk_anon_const(this, constant);
400400
});
401401
}
402402

403403
fn visit_expr(&mut self, expr: &'hir Expr) {
404-
self.insert(expr.id, NodeExpr(expr));
404+
self.insert(expr.id, NodeKind::Expr(expr));
405405

406406
self.with_parent(expr.id, |this| {
407407
intravisit::walk_expr(this, expr);
@@ -410,23 +410,23 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
410410

411411
fn visit_stmt(&mut self, stmt: &'hir Stmt) {
412412
let id = stmt.node.id();
413-
self.insert(id, NodeStmt(stmt));
413+
self.insert(id, NodeKind::Stmt(stmt));
414414

415415
self.with_parent(id, |this| {
416416
intravisit::walk_stmt(this, stmt);
417417
});
418418
}
419419

420420
fn visit_ty(&mut self, ty: &'hir Ty) {
421-
self.insert(ty.id, NodeTy(ty));
421+
self.insert(ty.id, NodeKind::Ty(ty));
422422

423423
self.with_parent(ty.id, |this| {
424424
intravisit::walk_ty(this, ty);
425425
});
426426
}
427427

428428
fn visit_trait_ref(&mut self, tr: &'hir TraitRef) {
429-
self.insert(tr.ref_id, NodeTraitRef(tr));
429+
self.insert(tr.ref_id, NodeKind::TraitRef(tr));
430430

431431
self.with_parent(tr.ref_id, |this| {
432432
intravisit::walk_trait_ref(this, tr);
@@ -440,21 +440,21 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
440440
}
441441

442442
fn visit_block(&mut self, block: &'hir Block) {
443-
self.insert(block.id, NodeBlock(block));
443+
self.insert(block.id, NodeKind::Block(block));
444444
self.with_parent(block.id, |this| {
445445
intravisit::walk_block(this, block);
446446
});
447447
}
448448

449449
fn visit_local(&mut self, l: &'hir Local) {
450-
self.insert(l.id, NodeLocal(l));
450+
self.insert(l.id, NodeKind::Local(l));
451451
self.with_parent(l.id, |this| {
452452
intravisit::walk_local(this, l)
453453
})
454454
}
455455

456456
fn visit_lifetime(&mut self, lifetime: &'hir Lifetime) {
457-
self.insert(lifetime.id, NodeLifetime(lifetime));
457+
self.insert(lifetime.id, NodeKind::Lifetime(lifetime));
458458
}
459459

460460
fn visit_vis(&mut self, visibility: &'hir Visibility) {
@@ -463,7 +463,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
463463
VisibilityKind::Crate(_) |
464464
VisibilityKind::Inherited => {}
465465
VisibilityKind::Restricted { id, .. } => {
466-
self.insert(id, NodeVisibility(visibility));
466+
self.insert(id, NodeKind::Visibility(visibility));
467467
self.with_parent(id, |this| {
468468
intravisit::walk_vis(this, visibility);
469469
});
@@ -475,20 +475,20 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
475475
let def_index = self.definitions.opt_def_index(macro_def.id).unwrap();
476476

477477
self.with_dep_node_owner(def_index, macro_def, |this| {
478-
this.insert(macro_def.id, NodeMacroDef(macro_def));
478+
this.insert(macro_def.id, NodeKind::MacroDef(macro_def));
479479
});
480480
}
481481

482482
fn visit_variant(&mut self, v: &'hir Variant, g: &'hir Generics, item_id: NodeId) {
483483
let id = v.node.data.id();
484-
self.insert(id, NodeVariant(v));
484+
self.insert(id, NodeKind::Variant(v));
485485
self.with_parent(id, |this| {
486486
intravisit::walk_variant(this, v, g, item_id);
487487
});
488488
}
489489

490490
fn visit_struct_field(&mut self, field: &'hir StructField) {
491-
self.insert(field.id, NodeField(field));
491+
self.insert(field.id, NodeKind::Field(field));
492492
self.with_parent(field.id, |this| {
493493
intravisit::walk_struct_field(this, field);
494494
});

0 commit comments

Comments
 (0)