Rename Pat.node to Pat.kind

Author: varkor

src/librustc/hir/intravisit.rs

@@ -696,7 +696,7 @@ pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(visitor: &mut V,
 
 pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {
     visitor.visit_id(pattern.hir_id);
-    match pattern.node {
+    match pattern.kind {
         PatKind::TupleStruct(ref qpath, ref children, _) => {
             visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);
             walk_list!(visitor, visit_pat, children);

src/librustc/hir/lowering.rs

@@ -425,7 +425,7 @@ impl<'a> LoweringContext<'a> {
 
         impl<'tcx, 'interner> Visitor<'tcx> for MiscCollector<'tcx, 'interner> {
             fn visit_pat(&mut self, p: &'tcx Pat) {
-                if let PatKind::Paren(..) | PatKind::Rest = p.node {
+                if let PatKind::Paren(..) | PatKind::Rest = p.kind {
                     // Doesn't generate a HIR node
                 } else if let Some(owner) = self.hir_id_owner {
                     self.lctx.lower_node_id_with_owner(p.id, owner);
@@ -2095,7 +2095,7 @@ impl<'a> LoweringContext<'a> {
     fn lower_fn_params_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Ident> {
         decl.inputs
             .iter()
-            .map(|param| match param.pat.node {
+            .map(|param| match param.pat.kind {
                 PatKind::Ident(_, ident, _) => ident,
                 _ => Ident::new(kw::Invalid, param.pat.span),
             })
@@ -2172,7 +2172,7 @@ impl<'a> LoweringContext<'a> {
             implicit_self: decl.inputs.get(0).map_or(
                 hir::ImplicitSelfKind::None,
                 |arg| {
-                    let is_mutable_pat = match arg.pat.node {
+                    let is_mutable_pat = match arg.pat.kind {
                         PatKind::Ident(BindingMode::ByValue(mt), _, _) |
                         PatKind::Ident(BindingMode::ByRef(mt), _, _) =>
                             mt == Mutability::Mutable,
@@ -2688,7 +2688,7 @@ impl<'a> LoweringContext<'a> {
     }
 
     fn lower_pat(&mut self, p: &Pat) -> P<hir::Pat> {
-        let node = match p.node {
+        let node = match p.kind {
             PatKind::Wild => hir::PatKind::Wild,
             PatKind::Ident(ref binding_mode, ident, ref sub) => {
                 let lower_sub = |this: &mut Self| sub.as_ref().map(|x| this.lower_pat(x));
@@ -2805,7 +2805,7 @@ impl<'a> LoweringContext<'a> {
         let mut iter = pats.iter();
         while let Some(pat) = iter.next() {
             // Interpret the first `((ref mut?)? x @)? ..` pattern as a subslice pattern.
-            match pat.node {
+            match pat.kind {
                 PatKind::Rest => {
                     prev_rest_span = Some(pat.span);
                     slice = Some(self.pat_wild_with_node_id_of(pat));
@@ -2827,7 +2827,7 @@ impl<'a> LoweringContext<'a> {
 
         while let Some(pat) = iter.next() {
             // There was a previous subslice pattern; make sure we don't allow more.
-            let rest_span = match pat.node {
+            let rest_span = match pat.kind {
                 PatKind::Rest => Some(pat.span),
                 PatKind::Ident(.., Some(ref sub)) if sub.is_rest() => {
                     // The `HirValidator` is merciless; add a `_` pattern to avoid ICEs.
@@ -2884,10 +2884,10 @@ impl<'a> LoweringContext<'a> {
     }
 
     /// Construct a `Pat` with the `HirId` of `p.id` lowered.
-    fn pat_with_node_id_of(&mut self, p: &Pat, node: hir::PatKind) -> P<hir::Pat> {
+    fn pat_with_node_id_of(&mut self, p: &Pat, kind: hir::PatKind) -> P<hir::Pat> {
         P(hir::Pat {
             hir_id: self.lower_node_id(p.id),
-            node,
+            kind,
             span: p.span,
         })
     }
@@ -3112,7 +3112,7 @@ impl<'a> LoweringContext<'a> {
         (
             P(hir::Pat {
                 hir_id,
-                node: hir::PatKind::Binding(bm, hir_id, ident.with_span_pos(span), None),
+                kind: hir::PatKind::Binding(bm, hir_id, ident.with_span_pos(span), None),
                 span,
             }),
             hir_id
@@ -3123,10 +3123,10 @@ impl<'a> LoweringContext<'a> {
         self.pat(span, hir::PatKind::Wild)
     }
 
-    fn pat(&mut self, span: Span, pat: hir::PatKind) -> P<hir::Pat> {
+    fn pat(&mut self, span: Span, kind: hir::PatKind) -> P<hir::Pat> {
         P(hir::Pat {
             hir_id: self.next_id(),
-            node: pat,
+            kind,
             span,
         })
     }

src/librustc/hir/lowering/item.rs

@@ -1133,7 +1133,7 @@ impl LoweringContext<'_> {
 
                 // Check if this is a binding pattern, if so, we can optimize and avoid adding a
                 // `let <pat> = __argN;` statement. In this case, we do not rename the parameter.
-                let (ident, is_simple_parameter) = match parameter.pat.node {
+                let (ident, is_simple_parameter) = match parameter.pat.kind {
                     hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ident, _) =>
                         (ident, true),
                     _ => {

src/librustc/hir/map/collector.rs

@@ -427,7 +427,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_pat(&mut self, pat: &'hir Pat) {
-        let node = if let PatKind::Binding(..) = pat.node {
+        let node = if let PatKind::Binding(..) = pat.kind {
             Node::Binding(pat)
         } else {
             Node::Pat(pat)

src/librustc/hir/map/def_collector.rs

@@ -257,7 +257,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
     }
 
     fn visit_pat(&mut self, pat: &'a Pat) {
-        match pat.node {
+        match pat.kind {
             PatKind::Mac(..) => return self.visit_macro_invoc(pat.id),
             _ => visit::walk_pat(self, pat),
         }

src/librustc/hir/map/mod.rs

@@ -948,7 +948,7 @@ impl<'hir> Map<'hir> {
             Node::Field(f) => f.ident.name,
             Node::Lifetime(lt) => lt.name.ident().name,
             Node::GenericParam(param) => param.name.ident().name,
-            Node::Binding(&Pat { node: PatKind::Binding(_, _, l, _), .. }) => l.name,
+            Node::Binding(&Pat { kind: PatKind::Binding(_, _, l, _), .. }) => l.name,
             Node::Ctor(..) => self.name(self.get_parent_item(id)),
             _ => bug!("no name for {}", self.node_to_string(id))
         }

src/librustc/hir/mod.rs

@@ -869,7 +869,7 @@ pub struct Block {
 pub struct Pat {
     #[stable_hasher(ignore)]
     pub hir_id: HirId,
-    pub node: PatKind,
+    pub kind: PatKind,
     pub span: Span,
 }
 
@@ -888,7 +888,7 @@ impl Pat {
         }
 
         use PatKind::*;
-        match &self.node {
+        match &self.kind {
             Wild | Lit(_) | Range(..) | Binding(.., None) | Path(_) => true,
             Box(s) | Ref(s, _) | Binding(.., Some(s)) => s.walk_short_(it),
             Struct(_, fields, _) => fields.iter().all(|field| field.pat.walk_short_(it)),
@@ -919,7 +919,7 @@ impl Pat {
         }
 
         use PatKind::*;
-        match &self.node {
+        match &self.kind {
             Wild | Lit(_) | Range(..) | Binding(.., None) | Path(_) => {},
             Box(s) | Ref(s, _) | Binding(.., Some(s)) => s.walk_(it),
             Struct(_, fields, _) => fields.iter().for_each(|field| field.pat.walk_(it)),
@@ -1295,7 +1295,7 @@ impl Arm {
     // HACK(or_patterns; Centril | dlrobertson): Remove this and
     // correctly handle each case in which this method is used.
     pub fn top_pats_hack(&self) -> &[P<Pat>] {
-        match &self.pat.node {
+        match &self.pat.kind {
             PatKind::Or(pats) => pats,
             _ => std::slice::from_ref(&self.pat),
         }

src/librustc/hir/pat_util.rs

@@ -45,7 +45,7 @@ impl<T: ExactSizeIterator> EnumerateAndAdjustIterator for T {
 
 impl hir::Pat {
     pub fn is_refutable(&self) -> bool {
-        match self.node {
+        match self.kind {
             PatKind::Lit(_) |
             PatKind::Range(..) |
             PatKind::Path(hir::QPath::Resolved(Some(..), _)) |
@@ -68,7 +68,7 @@ impl hir::Pat {
     /// `match foo() { Some(a) => (), None => () }`
     pub fn each_binding(&self, mut f: impl FnMut(hir::BindingAnnotation, HirId, Span, ast::Ident)) {
         self.walk(|p| {
-            if let PatKind::Binding(binding_mode, _, ident, _) = p.node {
+            if let PatKind::Binding(binding_mode, _, ident, _) = p.kind {
                 f(binding_mode, p.hir_id, p.span, ident);
             }
             true
@@ -83,7 +83,7 @@ impl hir::Pat {
         &self,
         f: &mut impl FnMut(hir::BindingAnnotation, HirId, Span, ast::Ident),
     ) {
-        self.walk(|p| match &p.node {
+        self.walk(|p| match &p.kind {
             PatKind::Or(ps) => {
                 ps[0].each_binding_or_first(f);
                 false
@@ -99,7 +99,7 @@ impl hir::Pat {
     /// Checks if the pattern contains any patterns that bind something to
     /// an ident, e.g., `foo`, or `Foo(foo)` or `foo @ Bar(..)`.
     pub fn contains_bindings(&self) -> bool {
-        self.satisfies(|p| match p.node {
+        self.satisfies(|p| match p.kind {
             PatKind::Binding(..) => true,
             _ => false,
         })
@@ -108,7 +108,7 @@ impl hir::Pat {
     /// Checks if the pattern contains any patterns that bind something to
     /// an ident or wildcard, e.g., `foo`, or `Foo(_)`, `foo @ Bar(..)`,
     pub fn contains_bindings_or_wild(&self) -> bool {
-        self.satisfies(|p| match p.node {
+        self.satisfies(|p| match p.kind {
             PatKind::Binding(..) | PatKind::Wild => true,
             _ => false,
         })
@@ -129,7 +129,7 @@ impl hir::Pat {
     }
 
     pub fn simple_ident(&self) -> Option<ast::Ident> {
-        match self.node {
+        match self.kind {
             PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ident, None) |
             PatKind::Binding(hir::BindingAnnotation::Mutable, _, ident, None) => Some(ident),
             _ => None,
@@ -139,7 +139,7 @@ impl hir::Pat {
     /// Returns variants that are necessary to exist for the pattern to match.
     pub fn necessary_variants(&self) -> Vec<DefId> {
         let mut variants = vec![];
-        self.walk(|p| match &p.node {
+        self.walk(|p| match &p.kind {
             PatKind::Or(_) => false,
             PatKind::Path(hir::QPath::Resolved(_, path)) |
             PatKind::TupleStruct(hir::QPath::Resolved(_, path), ..) |

src/librustc/hir/print.rs

@@ -1617,7 +1617,7 @@ impl<'a> State<'a> {
         self.ann.pre(self, AnnNode::Pat(pat));
         // Pat isn't normalized, but the beauty of it
         // is that it doesn't matter
-        match pat.node {
+        match pat.kind {
             PatKind::Wild => self.s.word("_"),
             PatKind::Binding(binding_mode, _, ident, ref sub) => {
                 match binding_mode {
@@ -1710,7 +1710,7 @@ impl<'a> State<'a> {
                 self.pclose();
             }
             PatKind::Box(ref inner) => {
-                let is_range_inner = match inner.node {
+                let is_range_inner = match inner.kind {
                     PatKind::Range(..) => true,
                     _ => false,
                 };
@@ -1724,7 +1724,7 @@ impl<'a> State<'a> {
                 }
             }
             PatKind::Ref(ref inner, mutbl) => {
-                let is_range_inner = match inner.node {
+                let is_range_inner = match inner.kind {
                     PatKind::Range(..) => true,
                     _ => false,
                 };
@@ -1757,7 +1757,7 @@ impl<'a> State<'a> {
                     if !before.is_empty() {
                         self.word_space(",");
                     }
-                    if let PatKind::Wild = p.node {
+                    if let PatKind::Wild = p.kind {
                         // Print nothing.
                     } else {
                         self.print_pat(&p);

src/librustc/hir/upvars.rs

@@ -47,7 +47,7 @@ impl Visitor<'tcx> for LocalCollector {
     }
 
     fn visit_pat(&mut self, pat: &'tcx hir::Pat) {
-        if let hir::PatKind::Binding(_, hir_id, ..) = pat.node {
+        if let hir::PatKind::Binding(_, hir_id, ..) = pat.kind {
             self.locals.insert(hir_id);
         }
         intravisit::walk_pat(self, pat);