Rename `Ty.node` to `Ty.kind`

[rust.git] / src / libsyntax / ext / expand.rs

diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 2cd802f22d306903a429acde2be723086339e899..98a4de4cfe94f7a1d41d2c91b86a9bf732af9ae4 100644 (file)
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -384,7 +384,7 @@ pub fn fully_expand_fragment(&mut self, input_fragment: AstFragment) -> AstFragm
                         let attr = attr::find_by_name(item.attrs(), sym::derive)
                             .expect("`derive` attribute should exist");
                         let span = attr.span;
-                        let mut err = self.cx.mut_span_err(span,
+                        let mut err = self.cx.struct_span_err(span,
                             "`derive` may only be applied to structs, enums and unions");
                         if let ast::AttrStyle::Inner = attr.style {
                             let trait_list = derives.iter()
@@ -1035,7 +1035,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
     fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
         self.cfg.configure_expr(expr);
         visit_clobber(expr.deref_mut(), |mut expr| {
-            self.cfg.configure_expr_kind(&mut expr.node);
+            self.cfg.configure_expr_kind(&mut expr.kind);
 
             // ignore derives so they remain unused
             let (attr, after_derive) = self.classify_nonitem(&mut expr);
@@ -1052,7 +1052,7 @@ fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
                     .into_inner()
             }
 
-            if let ast::ExprKind::Mac(mac) = expr.node {
+            if let ast::ExprKind::Mac(mac) = expr.kind {
                 self.check_attributes(&expr.attrs);
                 self.collect_bang(mac, expr.span, AstFragmentKind::Expr)
                     .make_expr()
@@ -1145,7 +1145,7 @@ fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
     fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
         let expr = configure!(self, expr);
         expr.filter_map(|mut expr| {
-            self.cfg.configure_expr_kind(&mut expr.node);
+            self.cfg.configure_expr_kind(&mut expr.kind);
 
             // Ignore derives so they remain unused.
             let (attr, after_derive) = self.classify_nonitem(&mut expr);
@@ -1159,7 +1159,7 @@ fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
                     .map(|expr| expr.into_inner())
             }
 
-            if let ast::ExprKind::Mac(mac) = expr.node {
+            if let ast::ExprKind::Mac(mac) = expr.kind {
                 self.check_attributes(&expr.attrs);
                 self.collect_bang(mac, expr.span, AstFragmentKind::OptExpr)
                     .make_opt_expr()
@@ -1172,13 +1172,13 @@ fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
 
     fn visit_pat(&mut self, pat: &mut P<ast::Pat>) {
         self.cfg.configure_pat(pat);
-        match pat.node {
+        match pat.kind {
             PatKind::Mac(_) => {}
             _ => return noop_visit_pat(pat, self),
         }
 
         visit_clobber(pat, |mut pat| {
-            match mem::replace(&mut pat.node, PatKind::Wild) {
+            match mem::replace(&mut pat.kind, PatKind::Wild) {
                 PatKind::Mac(mac) =>
                     self.collect_bang(mac, pat.span, AstFragmentKind::Pat).make_pat(),
                 _ => unreachable!(),
@@ -1318,7 +1318,7 @@ fn visit_block(&mut self, block: &mut P<Block>) {
                                      AstFragmentKind::TraitItems, after_derive).make_trait_items()
         }
 
-        match item.node {
+        match item.kind {
             ast::TraitItemKind::Macro(mac) => {
                 let ast::TraitItem { attrs, span, .. } = item;
                 self.check_attributes(&attrs);
@@ -1337,7 +1337,7 @@ fn visit_block(&mut self, block: &mut P<Block>) {
                                      AstFragmentKind::ImplItems, after_derive).make_impl_items();
         }
 
-        match item.node {
+        match item.kind {
             ast::ImplItemKind::Macro(mac) => {
                 let ast::ImplItem { attrs, span, .. } = item;
                 self.check_attributes(&attrs);
@@ -1348,13 +1348,13 @@ fn visit_block(&mut self, block: &mut P<Block>) {
     }
 
     fn visit_ty(&mut self, ty: &mut P<ast::Ty>) {
-        match ty.node {
+        match ty.kind {
             ast::TyKind::Mac(_) => {}
             _ => return noop_visit_ty(ty, self),
         };
 
         visit_clobber(ty, |mut ty| {
-            match mem::replace(&mut ty.node, ast::TyKind::Err) {
+            match mem::replace(&mut ty.kind, ast::TyKind::Err) {
                 ast::TyKind::Mac(mac) =>
                     self.collect_bang(mac, ty.span, AstFragmentKind::Ty).make_ty(),
                 _ => unreachable!(),
@@ -1504,7 +1504,7 @@ fn visit_attribute(&mut self, at: &mut ast::Attribute) {
                     // Check if the user erroneously used `doc(include(...))` syntax.
                     let literal = it.meta_item_list().and_then(|list| {
                         if list.len() == 1 {
-                            list[0].literal().map(|literal| &literal.node)
+                            list[0].literal().map(|literal| &literal.kind)
                         } else {
                             None
                         }