Rename TraitItem.node to TraitItem.kind

Author: varkor

src/librustc/hir/intravisit.rs

@@ -856,7 +856,7 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai
     visitor.visit_ident(trait_item.ident);
     walk_list!(visitor, visit_attribute, &trait_item.attrs);
     visitor.visit_generics(&trait_item.generics);
-    match trait_item.node {
+    match trait_item.kind {
         TraitItemKind::Const(ref ty, default) => {
             visitor.visit_id(trait_item.hir_id);
             visitor.visit_ty(ty);

src/librustc/hir/lowering.rs

@@ -469,7 +469,7 @@ impl<'a> LoweringContext<'a> {
             fn visit_trait_item(&mut self, item: &'tcx TraitItem) {
                 self.lctx.allocate_hir_id_counter(item.id);
 
-                match item.node {
+                match item.kind {
                     TraitItemKind::Method(_, None) => {
                         // Ignore patterns in trait methods without bodies
                         self.with_hir_id_owner(None, |this| {

src/librustc/hir/lowering/item.rs

@@ -818,7 +818,7 @@ impl LoweringContext<'_> {
     fn lower_trait_item(&mut self, i: &TraitItem) -> hir::TraitItem {
         let trait_item_def_id = self.resolver.definitions().local_def_id(i.id);
 
-        let (generics, node) = match i.node {
+        let (generics, kind) = match i.kind {
             TraitItemKind::Const(ref ty, ref default) => (
                 self.lower_generics(&i.generics, ImplTraitContext::disallowed()),
                 hir::TraitItemKind::Const(
@@ -852,14 +852,14 @@ impl LoweringContext<'_> {
             }
             TraitItemKind::Type(ref bounds, ref default) => {
                 let generics = self.lower_generics(&i.generics, ImplTraitContext::disallowed());
-                let node = hir::TraitItemKind::Type(
+                let kind = hir::TraitItemKind::Type(
                     self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
                     default
                         .as_ref()
                         .map(|x| self.lower_ty(x, ImplTraitContext::disallowed())),
                 );
 
-                (generics, node)
+                (generics, kind)
             },
             TraitItemKind::Macro(..) => bug!("macro item shouldn't exist at this point"),
         };
@@ -869,13 +869,13 @@ impl LoweringContext<'_> {
             ident: i.ident,
             attrs: self.lower_attrs(&i.attrs),
             generics,
-            node,
+            kind,
             span: i.span,
         }
     }
 
     fn lower_trait_item_ref(&mut self, i: &TraitItem) -> hir::TraitItemRef {
-        let (kind, has_default) = match i.node {
+        let (kind, has_default) = match i.kind {
             TraitItemKind::Const(_, ref default) => {
                 (hir::AssocItemKind::Const, default.is_some())
             }

src/librustc/hir/map/blocks.rs

@@ -52,7 +52,7 @@ impl MaybeFnLike for ast::ImplItem {
 
 impl MaybeFnLike for ast::TraitItem {
     fn is_fn_like(&self) -> bool {
-        match self.node {
+        match self.kind {
             ast::TraitItemKind::Method(_, ast::TraitMethod::Provided(_)) => true,
             _ => false,
         }
@@ -230,7 +230,7 @@ impl<'a> FnLikeNode<'a> {
                     }),
                 _ => bug!("item FnLikeNode that is not fn-like"),
             },
-            map::Node::TraitItem(ti) => match ti.node {
+            map::Node::TraitItem(ti) => match ti.kind {
                 ast::TraitItemKind::Method(ref sig, ast::TraitMethod::Provided(body)) => {
                     method(ti.hir_id, ti.ident, sig, None, body, ti.span, &ti.attrs)
                 }

src/librustc/hir/map/def_collector.rs

@@ -214,7 +214,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
     }
 
     fn visit_trait_item(&mut self, ti: &'a TraitItem) {
-        let def_data = match ti.node {
+        let def_data = match ti.kind {
             TraitItemKind::Method(..) | TraitItemKind::Const(..) =>
                 DefPathData::ValueNs(ti.ident.as_interned_str()),
             TraitItemKind::Type(..) => {

src/librustc/hir/map/mod.rs

@@ -57,7 +57,7 @@ impl<'hir> Entry<'hir> {
             }
 
             Node::TraitItem(ref item) => {
-                match item.node {
+                match item.kind {
                     TraitItemKind::Method(ref method_sig, _) => Some(&method_sig.decl),
                     _ => None
                 }
@@ -93,7 +93,7 @@ impl<'hir> Entry<'hir> {
             }
 
             Node::TraitItem(item) => {
-                match item.node {
+                match item.kind {
                     TraitItemKind::Const(_, Some(body)) |
                     TraitItemKind::Method(_, TraitMethod::Provided(body)) => Some(body),
                     _ => None
@@ -320,7 +320,7 @@ impl<'hir> Map<'hir> {
                 }
             }
             Node::TraitItem(item) => {
-                match item.node {
+                match item.kind {
                     TraitItemKind::Const(..) => DefKind::AssocConst,
                     TraitItemKind::Method(..) => DefKind::Method,
                     TraitItemKind::Type(..) => DefKind::AssocTy,
@@ -454,14 +454,14 @@ impl<'hir> Map<'hir> {
     pub fn body_owner_kind(&self, id: HirId) -> BodyOwnerKind {
         match self.get(id) {
             Node::Item(&Item { node: ItemKind::Const(..), .. }) |
-            Node::TraitItem(&TraitItem { node: TraitItemKind::Const(..), .. }) |
+            Node::TraitItem(&TraitItem { kind: TraitItemKind::Const(..), .. }) |
             Node::ImplItem(&ImplItem { kind: ImplItemKind::Const(..), .. }) |
             Node::AnonConst(_) => {
                 BodyOwnerKind::Const
             }
             Node::Ctor(..) |
             Node::Item(&Item { node: ItemKind::Fn(..), .. }) |
-            Node::TraitItem(&TraitItem { node: TraitItemKind::Method(..), .. }) |
+            Node::TraitItem(&TraitItem { kind: TraitItemKind::Method(..), .. }) |
             Node::ImplItem(&ImplItem { kind: ImplItemKind::Method(..), .. }) => {
                 BodyOwnerKind::Fn
             }
@@ -653,7 +653,7 @@ impl<'hir> Map<'hir> {
                 ..
             })
             | Node::TraitItem(&TraitItem {
-                node: TraitItemKind::Const(..),
+                kind: TraitItemKind::Const(..),
                 ..
             })
             | Node::ImplItem(&ImplItem {
@@ -826,7 +826,7 @@ impl<'hir> Map<'hir> {
                 }
             },
             Node::TraitItem(ti) => {
-                match ti.node {
+                match ti.kind {
                     TraitItemKind::Method(..) => true,
                     _ => false,
                 }
@@ -1326,7 +1326,7 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId, include_id: bool) -> String {
             }
         }
         Some(Node::TraitItem(ti)) => {
-            let kind = match ti.node {
+            let kind = match ti.kind {
                 TraitItemKind::Const(..) => "assoc constant",
                 TraitItemKind::Method(..) => "trait method",
                 TraitItemKind::Type(..) => "assoc type",

src/librustc/hir/mod.rs

@@ -1830,7 +1830,7 @@ pub struct TraitItem {
     pub hir_id: HirId,
     pub attrs: HirVec<Attribute>,
     pub generics: Generics,
-    pub node: TraitItemKind,
+    pub kind: TraitItemKind,
     pub span: Span,
 }
 

src/librustc/hir/print.rs

@@ -858,7 +858,7 @@ impl<'a> State<'a> {
         self.hardbreak_if_not_bol();
         self.maybe_print_comment(ti.span.lo());
         self.print_outer_attributes(&ti.attrs);
-        match ti.node {
+        match ti.kind {
             hir::TraitItemKind::Const(ref ty, default) => {
                 let vis = Spanned { span: syntax_pos::DUMMY_SP,
                                     node: hir::VisibilityKind::Inherited };

src/librustc/ich/impls_hir.rs

@@ -200,15 +200,15 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::TraitItem {
             ident,
             ref attrs,
             ref generics,
-            ref node,
+            ref kind,
             span
         } = *self;
 
         hcx.hash_hir_item_like(|hcx| {
             ident.name.hash_stable(hcx, hasher);
             attrs.hash_stable(hcx, hasher);
             generics.hash_stable(hcx, hasher);
-            node.hash_stable(hcx, hasher);
+            kind.hash_stable(hcx, hasher);
             span.hash_stable(hcx, hasher);
         });
     }

src/librustc/infer/error_reporting/mod.rs

@@ -260,7 +260,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     fn trait_item_scope_tag(item: &hir::TraitItem) -> &'static str {
-        match item.node {
+        match item.kind {
             hir::TraitItemKind::Method(..) => "method body",
             hir::TraitItemKind::Const(..) | hir::TraitItemKind::Type(..) => "associated item",
         }