Rename ast::Pat_ and its variants

3 files changed, 24 insertions, 24 deletions

diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index b4e86e4cfd3..8fc72418eb0 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -11,7 +11,7 @@
 pub use self::SyntaxExtension::*;
 
 use ast;
-use ast::Name;
+use ast::{Name, PatKind};
 use codemap;
 use codemap::{CodeMap, Span, ExpnId, ExpnInfo, NO_EXPANSION};
 use errors::DiagnosticBuilder;
@@ -307,7 +307,7 @@ impl MacResult for MacEager {
                 return Some(P(ast::Pat {
                     id: ast::DUMMY_NODE_ID,
                     span: e.span,
-                    node: ast::PatLit(e),
+                    node: PatKind::Lit(e),
                 }));
             }
         }
@@ -359,7 +359,7 @@ impl DummyResult {
     pub fn raw_pat(sp: Span) -> ast::Pat {
         ast::Pat {
             id: ast::DUMMY_NODE_ID,
-            node: ast::PatWild,
+            node: PatKind::Wild,
             span: sp,
         }
     }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 38af8353aea..312154e5a8d 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use abi::Abi;
-use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp};
+use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp, PatKind};
 use attr;
 use codemap::{Span, respan, Spanned, DUMMY_SP, Pos};
 use ext::base::ExtCtxt;
@@ -166,7 +166,7 @@ pub trait AstBuilder {
     fn expr_err(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Expr>;
     fn expr_try(&self, span: Span, head: P<ast::Expr>) -> P<ast::Expr>;
 
-    fn pat(&self, span: Span, pat: ast::Pat_) -> P<ast::Pat>;
+    fn pat(&self, span: Span, pat: PatKind) -> P<ast::Pat>;
     fn pat_wild(&self, span: Span) -> P<ast::Pat>;
     fn pat_lit(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Pat>;
     fn pat_ident(&self, span: Span, ident: ast::Ident) -> P<ast::Pat>;
@@ -805,14 +805,14 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
 
-    fn pat(&self, span: Span, pat: ast::Pat_) -> P<ast::Pat> {
+    fn pat(&self, span: Span, pat: PatKind) -> P<ast::Pat> {
         P(ast::Pat { id: ast::DUMMY_NODE_ID, node: pat, span: span })
     }
     fn pat_wild(&self, span: Span) -> P<ast::Pat> {
-        self.pat(span, ast::PatWild)
+        self.pat(span, PatKind::Wild)
     }
     fn pat_lit(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Pat> {
-        self.pat(span, ast::PatLit(expr))
+        self.pat(span, PatKind::Lit(expr))
     }
     fn pat_ident(&self, span: Span, ident: ast::Ident) -> P<ast::Pat> {
         let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Immutable);
@@ -823,20 +823,20 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                               span: Span,
                               ident: ast::Ident,
                               bm: ast::BindingMode) -> P<ast::Pat> {
-        let pat = ast::PatIdent(bm, Spanned{span: span, node: ident}, None);
+        let pat = PatKind::Ident(bm, Spanned{span: span, node: ident}, None);
         self.pat(span, pat)
     }
     fn pat_enum(&self, span: Span, path: ast::Path, subpats: Vec<P<ast::Pat>>) -> P<ast::Pat> {
-        let pat = ast::PatEnum(path, Some(subpats));
+        let pat = PatKind::Enum(path, Some(subpats));
         self.pat(span, pat)
     }
     fn pat_struct(&self, span: Span,
                   path: ast::Path, field_pats: Vec<Spanned<ast::FieldPat>>) -> P<ast::Pat> {
-        let pat = ast::PatStruct(path, field_pats, false);
+        let pat = PatKind::Struct(path, field_pats, false);
         self.pat(span, pat)
     }
     fn pat_tuple(&self, span: Span, pats: Vec<P<ast::Pat>>) -> P<ast::Pat> {
-        self.pat(span, ast::PatTup(pats))
+        self.pat(span, PatKind::Tup(pats))
     }
 
     fn pat_some(&self, span: Span, pat: P<ast::Pat>) -> P<ast::Pat> {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 123a21fb8f0..e8e042c1321 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::{Block, Crate, DeclKind, PatMac};
+use ast::{Block, Crate, DeclKind, PatKind};
 use ast::{Local, Ident, Mac_, Name};
 use ast::{MacStmtStyle, Mrk, Stmt, StmtKind, ItemKind};
 use ast::TokenTree;
@@ -666,7 +666,7 @@ fn rename_in_scope<X, F>(pats: Vec<P<ast::Pat>>,
     (f(&mut rename_fld, fld, x), rewritten_pats)
 }
 
-/// A visitor that extracts the PatIdent (binding) paths
+/// A visitor that extracts the PatKind::Ident (binding) paths
 /// from a given thingy and puts them in a mutable
 /// array
 #[derive(Clone)]
@@ -677,9 +677,9 @@ struct PatIdentFinder {
 impl<'v> Visitor<'v> for PatIdentFinder {
     fn visit_pat(&mut self, pattern: &ast::Pat) {
         match *pattern {
-            ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => {
+            ast::Pat { id: _, node: PatKind::Ident(_, ref path1, ref inner), span: _ } => {
                 self.ident_accumulator.push(path1.node);
-                // visit optional subpattern of PatIdent:
+                // visit optional subpattern of PatKind::Ident:
                 if let Some(ref subpat) = *inner {
                     self.visit_pat(subpat)
                 }
@@ -690,14 +690,14 @@ impl<'v> Visitor<'v> for PatIdentFinder {
     }
 }
 
-/// find the PatIdent paths in a pattern
+/// find the PatKind::Ident paths in a pattern
 fn pattern_bindings(pat: &ast::Pat) -> Vec<ast::Ident> {
     let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
     name_finder.visit_pat(pat);
     name_finder.ident_accumulator
 }
 
-/// find the PatIdent paths in a
+/// find the PatKind::Ident paths in a
 fn fn_decl_arg_bindings(fn_decl: &ast::FnDecl) -> Vec<ast::Ident> {
     let mut pat_idents = PatIdentFinder{ident_accumulator:Vec::new()};
     for arg in &fn_decl.inputs {
@@ -746,12 +746,12 @@ pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
 
 fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
     match p.node {
-        PatMac(_) => {}
+        PatKind::Mac(_) => {}
         _ => return noop_fold_pat(p, fld)
     }
     p.map(|ast::Pat {node, span, ..}| {
         let (pth, tts) = match node {
-            PatMac(mac) => (mac.node.path, mac.node.tts),
+            PatKind::Mac(mac) => (mac.node.path, mac.node.tts),
             _ => unreachable!()
         };
         if pth.segments.len() > 1 {
@@ -840,7 +840,7 @@ impl<'a> Folder for IdentRenamer<'a> {
 }
 
 /// A tree-folder that applies every rename in its list to
-/// the idents that are in PatIdent patterns. This is more narrowly
+/// the idents that are in PatKind::Ident patterns. This is more narrowly
 /// focused than IdentRenamer, and is needed for FnDecl,
 /// where we want to rename the args but not the fn name or the generics etc.
 pub struct PatIdentRenamer<'a> {
@@ -850,16 +850,16 @@ pub struct PatIdentRenamer<'a> {
 impl<'a> Folder for PatIdentRenamer<'a> {
     fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
         match pat.node {
-            ast::PatIdent(..) => {},
+            PatKind::Ident(..) => {},
             _ => return noop_fold_pat(pat, self)
         }
 
         pat.map(|ast::Pat {id, node, span}| match node {
-            ast::PatIdent(binding_mode, Spanned{span: sp, node: ident}, sub) => {
+            PatKind::Ident(binding_mode, Spanned{span: sp, node: ident}, sub) => {
                 let new_ident = Ident::new(ident.name,
                                            mtwt::apply_renames(self.renames, ident.ctxt));
                 let new_node =
-                    ast::PatIdent(binding_mode,
+                    PatKind::Ident(binding_mode,
                                   Spanned{span: self.new_span(sp), node: new_ident},
                                   sub.map(|p| self.fold_pat(p)));
                 ast::Pat {