Remove Spanned from {ast,hir}::FieldPat

petrochenkov · petrochenkov · commit a6182711efe3 · 2019-08-15T12:31:50.000+03:00
diff --git a/src/librustc/cfg/construct.rs b/src/librustc/cfg/construct.rs
@@ -136,7 +136,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             }
 
             PatKind::Struct(_, ref subpats, _) => {
-                let pats_exit = self.pats_all(subpats.iter().map(|f| &f.node.pat), pred);
+                let pats_exit = self.pats_all(subpats.iter().map(|f| &f.pat), pred);
                 self.add_ast_node(pat.hir_id.local_id, &[pats_exit])
             }
 
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
@@ -704,9 +704,9 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {
         PatKind::Struct(ref qpath, ref fields, _) => {
             visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);
             for field in fields {
-                visitor.visit_id(field.node.hir_id);
-                visitor.visit_ident(field.node.ident);
-                visitor.visit_pat(&field.node.pat)
+                visitor.visit_id(field.hir_id);
+                visitor.visit_ident(field.ident);
+                visitor.visit_pat(&field.pat)
             }
         }
         PatKind::Tuple(ref tuple_elements, _) => {
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -2691,16 +2691,12 @@ impl<'a> LoweringContext<'a> {
 
                 let fs = fields
                     .iter()
-                    .map(|f| {
-                        Spanned {
-                            span: f.span,
-                            node: hir::FieldPat {
-                                hir_id: self.next_id(),
-                                ident: f.node.ident,
-                                pat: self.lower_pat(&f.node.pat),
-                                is_shorthand: f.node.is_shorthand,
-                            },
-                        }
+                    .map(|f| hir::FieldPat {
+                        hir_id: self.next_id(),
+                        ident: f.ident,
+                        pat: self.lower_pat(&f.pat),
+                        is_shorthand: f.is_shorthand,
+                        span: f.span,
                     })
                     .collect();
                 hir::PatKind::Struct(qpath, fs, etc)
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
@@ -877,7 +877,7 @@ impl Pat {
         match self.node {
             PatKind::Binding(.., Some(ref p)) => p.walk_(it),
             PatKind::Struct(_, ref fields, _) => {
-                fields.iter().all(|field| field.node.pat.walk_(it))
+                fields.iter().all(|field| field.pat.walk_(it))
             }
             PatKind::TupleStruct(_, ref s, _) | PatKind::Tuple(ref s, _) => {
                 s.iter().all(|p| p.walk_(it))
@@ -923,6 +923,7 @@ pub struct FieldPat {
     /// The pattern the field is destructured to.
     pub pat: P<Pat>,
     pub is_shorthand: bool,
+    pub span: Span,
 }
 
 /// Explicit binding annotations given in the HIR for a binding. Note
@@ -968,7 +969,7 @@ pub enum PatKind {
 
     /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
     /// The `bool` is `true` in the presence of a `..`.
-    Struct(QPath, HirVec<Spanned<FieldPat>>, bool),
+    Struct(QPath, HirVec<FieldPat>, bool),
 
     /// A tuple struct/variant pattern `Variant(x, y, .., z)`.
     /// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
@@ -1670,14 +1670,14 @@ impl<'a> State<'a> {
                                    &fields[..],
                                    |s, f| {
                                        s.cbox(INDENT_UNIT);
-                                       if !f.node.is_shorthand {
-                                           s.print_ident(f.node.ident);
+                                       if !f.is_shorthand {
+                                           s.print_ident(f.ident);
                                            s.word_nbsp(":");
                                        }
-                                       s.print_pat(&f.node.pat);
+                                       s.print_pat(&f.pat);
                                        s.end()
                                    },
-                                   |f| f.node.pat.span);
+                                   |f| f.pat.span);
                 if etc {
                     if !fields.is_empty() {
                         self.word_space(",");
diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs
@@ -153,8 +153,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::Ty {
     }
 }
 
-impl_stable_hash_for_spanned!(hir::FieldPat);
-
 impl_stable_hash_for_spanned!(hir::BinOpKind);
 
 impl_stable_hash_for!(struct hir::Stmt {
@@ -187,8 +185,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::Expr {
 
 impl_stable_hash_for_spanned!(usize);
 
-impl_stable_hash_for_spanned!(ast::Ident);
-
 impl_stable_hash_for!(struct ast::Ident {
     name,
     span,
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
@@ -17,8 +17,7 @@ use crate::util::nodemap::FxHashSet;
 
 use rustc_data_structures::fx::FxHashMap;
 
-use syntax::{ast, source_map};
-use syntax::attr;
+use syntax::{ast, attr};
 use syntax::symbol::sym;
 use syntax_pos;
 
@@ -119,17 +118,16 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
         }
     }
 
-    fn handle_field_pattern_match(&mut self, lhs: &hir::Pat, res: Res,
-                                  pats: &[source_map::Spanned<hir::FieldPat>]) {
+    fn handle_field_pattern_match(&mut self, lhs: &hir::Pat, res: Res, pats: &[hir::FieldPat]) {
         let variant = match self.tables.node_type(lhs.hir_id).sty {
             ty::Adt(adt, _) => adt.variant_of_res(res),
             _ => span_bug!(lhs.span, "non-ADT in struct pattern")
         };
         for pat in pats {
-            if let PatKind::Wild = pat.node.pat.node {
+            if let PatKind::Wild = pat.pat.node {
                 continue;
             }
-            let index = self.tcx.field_index(pat.node.hir_id, self.tables);
+            let index = self.tcx.field_index(pat.hir_id, self.tables);
             self.insert_def_id(variant.fields[index].did);
         }
     }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -418,8 +418,8 @@ fn add_from_pat<'tcx>(ir: &mut IrMaps<'tcx>, pat: &P<hir::Pat>) {
             }
             Struct(_, ref fields, _) => {
                 for field in fields {
-                    if field.node.is_shorthand {
-                        shorthand_field_ids.insert(field.node.pat.hir_id);
+                    if field.is_shorthand {
+                        shorthand_field_ids.insert(field.pat.hir_id);
                     }
                 }
             }
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
@@ -1282,11 +1282,11 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
                 };
 
                 for fp in field_pats {
-                    let field_ty = self.pat_ty_adjusted(&fp.node.pat)?; // see (*2)
-                    let f_index = self.tcx.field_index(fp.node.hir_id, self.tables);
+                    let field_ty = self.pat_ty_adjusted(&fp.pat)?; // see (*2)
+                    let f_index = self.tcx.field_index(fp.hir_id, self.tables);
                     let cmt_field = Rc::new(self.cat_field(pat, cmt.clone(), f_index,
-                                                           fp.node.ident, field_ty));
-                    self.cat_pattern_(cmt_field, &fp.node.pat, op)?;
+                                                           fp.ident, field_ty));
+                    self.cat_pattern_(cmt_field, &fp.pat, op)?;
                 }
             }
 
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -1207,7 +1207,7 @@ fn resolve_local<'tcx>(
             PatKind::Binding(hir::BindingAnnotation::RefMut, ..) => true,
 
             PatKind::Struct(_, ref field_pats, _) => {
-                field_pats.iter().any(|fp| is_binding_pat(&fp.node.pat))
+                field_pats.iter().any(|fp| is_binding_pat(&fp.pat))
             }
 
             PatKind::Slice(ref pats1, ref pats2, ref pats3) => {
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -164,7 +164,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonShorthandFieldPatterns {
                                    .expect("struct pattern type is not an ADT")
                                    .variant_of_res(cx.tables.qpath_res(qpath, pat.hir_id));
             for fieldpat in field_pats {
-                if fieldpat.node.is_shorthand {
+                if fieldpat.is_shorthand {
                     continue;
                 }
                 if fieldpat.span.ctxt().outer_expn_info().is_some() {
@@ -173,9 +173,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonShorthandFieldPatterns {
                     // (Issue #49588)
                     continue;
                 }
-                if let PatKind::Binding(_, _, ident, None) = fieldpat.node.pat.node {
+                if let PatKind::Binding(_, _, ident, None) = fieldpat.pat.node {
                     if cx.tcx.find_field_index(ident, &variant) ==
-                       Some(cx.tcx.field_index(fieldpat.node.hir_id, cx.tables)) {
+                       Some(cx.tcx.field_index(fieldpat.hir_id, cx.tables)) {
                         let mut err = cx.struct_span_lint(NON_SHORTHAND_FIELD_PATTERNS,
                                      fieldpat.span,
                                      &format!("the `{}:` in this pattern is redundant", ident));
diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs
@@ -645,9 +645,9 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
                     fields.iter()
                           .map(|field| {
                               FieldPattern {
-                                  field: Field::new(self.tcx.field_index(field.node.hir_id,
+                                  field: Field::new(self.tcx.field_index(field.hir_id,
                                                                          self.tables)),
-                                  pattern: self.lower_pattern(&field.node.pat),
+                                  pattern: self.lower_pattern(&field.pat),
                               }
                           })
                           .collect();
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -1075,8 +1075,8 @@ impl<'a, 'tcx> Visitor<'tcx> for NamePrivacyVisitor<'a, 'tcx> {
                 let adt = self.tables.pat_ty(pat).ty_adt_def().unwrap();
                 let variant = adt.variant_of_res(res);
                 for field in fields {
-                    let use_ctxt = field.node.ident.span;
-                    let index = self.tcx.field_index(field.node.hir_id, self.tables);
+                    let use_ctxt = field.ident.span;
+                    let index = self.tcx.field_index(field.hir_id, self.tables);
                     self.check_field(use_ctxt, field.span, adt, &variant.fields[index]);
                 }
             }
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -32,7 +32,7 @@ use syntax::print::pprust::{
     ty_to_string
 };
 use syntax::ptr::P;
-use syntax::source_map::{Spanned, DUMMY_SP, respan};
+use syntax::source_map::{DUMMY_SP, respan};
 use syntax::walk_list;
 use syntax_pos::*;
 
@@ -879,7 +879,7 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
                 };
                 let variant = adt.variant_of_res(self.save_ctxt.get_path_res(p.id));
 
-                for &Spanned { node: ref field, .. } in fields {
+                for field in fields {
                     if let Some(index) = self.tcx.find_field_index(field.ident, variant) {
                         if !self.span.filter_generated(field.ident.span) {
                             let span = self.span_from_span(field.ident.span);
diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs
@@ -12,7 +12,6 @@ use rustc::traits::{ObligationCause, ObligationCauseCode};
 use rustc::ty::{self, Ty, TypeFoldable};
 use rustc::ty::subst::Kind;
 use syntax::ast;
-use syntax::source_map::Spanned;
 use syntax::util::lev_distance::find_best_match_for_name;
 use syntax_pos::Span;
 use syntax_pos::hygiene::DesugaringKind;
@@ -1036,7 +1035,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
         &self,
         pat: &'tcx hir::Pat,
         qpath: &hir::QPath,
-        fields: &'tcx [Spanned<hir::FieldPat>],
+        fields: &'tcx [hir::FieldPat],
         etc: bool,
         expected: Ty<'tcx>,
         def_bm: ty::BindingMode,
@@ -1048,7 +1047,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
             variant_ty
         } else {
             for field in fields {
-                self.check_pat_walk(&field.node.pat, self.tcx.types.err, def_bm, discrim_span);
+                self.check_pat_walk(&field.pat, self.tcx.types.err, def_bm, discrim_span);
             }
             return self.tcx.types.err;
         };
@@ -1206,7 +1205,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
         pat_id: hir::HirId,
         span: Span,
         variant: &'tcx ty::VariantDef,
-        fields: &'tcx [Spanned<hir::FieldPat>],
+        fields: &'tcx [hir::FieldPat],
         etc: bool,
         def_bm: ty::BindingMode,
     ) -> bool {
@@ -1231,7 +1230,8 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
 
         let mut inexistent_fields = vec![];
         // Typecheck each field.
-        for &Spanned { node: ref field, span } in fields {
+        for field in fields {
+            let span = field.span;
             let ident = tcx.adjust_ident(field.ident, variant.def_id);
             let field_ty = match used_fields.entry(ident) {
                 Occupied(occupied) => {
diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs
@@ -283,7 +283,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
             }
             hir::PatKind::Struct(_, ref fields, _) => {
                 for field in fields {
-                    self.visit_field_id(field.node.hir_id);
+                    self.visit_field_id(field.hir_id);
                 }
             }
             _ => {}
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -29,7 +29,7 @@ use rustc::util::nodemap::{FxHashMap, FxHashSet};
 use syntax::ast::{self, AttrStyle, Ident};
 use syntax::attr;
 use syntax::ext::base::MacroKind;
-use syntax::source_map::{DUMMY_SP, Spanned};
+use syntax::source_map::DUMMY_SP;
 use syntax::symbol::{Symbol, kw, sym};
 use syntax::symbol::InternedString;
 use syntax_pos::{self, Pos, FileName};
@@ -4102,8 +4102,7 @@ fn name_from_pat(p: &hir::Pat) -> String {
         PatKind::TupleStruct(ref p, ..) | PatKind::Path(ref p) => qpath_to_string(p),
         PatKind::Struct(ref name, ref fields, etc) => {
             format!("{} {{ {}{} }}", qpath_to_string(name),
-                fields.iter().map(|&Spanned { node: ref fp, .. }|
-                                  format!("{}: {}", fp.ident, name_from_pat(&*fp.pat)))
+                fields.iter().map(|fp| format!("{}: {}", fp.ident, name_from_pat(&fp.pat)))
                              .collect::<Vec<String>>().join(", "),
                 if etc { ", .." } else { "" }
             )
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -571,7 +571,7 @@ impl Pat {
 
         match &self.node {
             PatKind::Ident(_, _, Some(p)) => p.walk(it),
-            PatKind::Struct(_, fields, _) => fields.iter().all(|field| field.node.pat.walk(it)),
+            PatKind::Struct(_, fields, _) => fields.iter().all(|field| field.pat.walk(it)),
             PatKind::TupleStruct(_, s) | PatKind::Tuple(s) | PatKind::Slice(s) => {
                 s.iter().all(|p| p.walk(it))
             }
@@ -609,6 +609,7 @@ pub struct FieldPat {
     pub is_shorthand: bool,
     pub attrs: ThinVec<Attribute>,
     pub id: NodeId,
+    pub span: Span,
 }
 
 #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)]
@@ -642,7 +643,7 @@ pub enum PatKind {
 
     /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
     /// The `bool` is `true` in the presence of a `..`.
-    Struct(Path, Vec<Spanned<FieldPat>>, /* recovered */ bool),
+    Struct(Path, Vec<FieldPat>, /* recovered */ bool),
 
     /// A tuple struct/variant pattern (`Variant(x, y, .., z)`).
     TupleStruct(Path, Vec<P<Pat>>),
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -575,7 +575,7 @@ impl<'a> ExtCtxt<'a> {
         self.pat(span, PatKind::TupleStruct(path, subpats))
     }
     pub fn pat_struct(&self, span: Span, path: ast::Path,
-                  field_pats: Vec<Spanned<ast::FieldPat>>) -> P<ast::Pat> {
+                      field_pats: Vec<ast::FieldPat>) -> P<ast::Pat> {
         self.pat(span, PatKind::Struct(path, field_pats, false))
     }
     pub fn pat_tuple(&self, span: Span, pats: Vec<P<ast::Pat>>) -> P<ast::Pat> {
diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs
@@ -1042,10 +1042,7 @@ pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
         }
         PatKind::Struct(path, fields, _etc) => {
             vis.visit_path(path);
-            for Spanned {
-                node: FieldPat { ident, pat, is_shorthand: _, attrs, id },
-                span
-            } in fields {
+            for FieldPat { ident, pat, is_shorthand: _, attrs, id, span } in fields {
                 vis.visit_ident(ident);
                 vis.visit_id(id);
                 vis.visit_pat(pat);
diff --git a/src/libsyntax/parse/parser/pat.rs b/src/libsyntax/parse/parser/pat.rs
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`PatKind::Struct(_, ref subpats, _) => {`
`139`		`- let pats_exit = self.pats_all(subpats.iter().map(\|f\| &f.node.pat), pred);`
	`139`	`+ let pats_exit = self.pats_all(subpats.iter().map(\|f\| &f.pat), pred);`
`140`	`140`	`self.add_ast_node(pat.hir_id.local_id, &[pats_exit])`
`141`	`141`	`}`
`142`	`142`
Original file line number	Diff line number	Diff line change
`@@ -704,9 +704,9 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {`
`704`	`704`	`PatKind::Struct(ref qpath, ref fields, _) => {`
`705`	`705`	`visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);`
`706`	`706`	`for field in fields {`
`707`		`- visitor.visit_id(field.node.hir_id);`
`708`		`- visitor.visit_ident(field.node.ident);`
`709`		`- visitor.visit_pat(&field.node.pat)`
	`707`	`+ visitor.visit_id(field.hir_id);`
	`708`	`+ visitor.visit_ident(field.ident);`
	`709`	`+ visitor.visit_pat(&field.pat)`
`710`	`710`	`}`
`711`	`711`	`}`
`712`	`712`	`PatKind::Tuple(ref tuple_elements, _) => {`
Original file line number	Diff line number	Diff line change
`@@ -153,8 +153,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::Ty {`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
`156`		`-impl_stable_hash_for_spanned!(hir::FieldPat);`
`157`		`-`
`158`	`156`	`impl_stable_hash_for_spanned!(hir::BinOpKind);`
`159`	`157`
`160`	`158`	`impl_stable_hash_for!(struct hir::Stmt {`
`@@ -187,8 +185,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::Expr {`
`187`	`185`
`188`	`186`	`impl_stable_hash_for_spanned!(usize);`
`189`	`187`
`190`		`-impl_stable_hash_for_spanned!(ast::Ident);`
`191`		`-`
`192`	`188`	`impl_stable_hash_for!(struct ast::Ident {`
`193`	`189`	`name,`
`194`	`190`	`span,`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,7 @@ use crate::util::nodemap::FxHashSet;`
`17`	`17`
`18`	`18`	`use rustc_data_structures::fx::FxHashMap;`
`19`	`19`
`20`		`-use syntax::{ast, source_map};`
`21`		`-use syntax::attr;`
	`20`	`+use syntax::{ast, attr};`
`22`	`21`	`use syntax::symbol::sym;`
`23`	`22`	`use syntax_pos;`
`24`	`23`
`@@ -119,17 +118,16 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {`
`119`	`118`	`}`
`120`	`119`	`}`
`121`	`120`
`122`		`- fn handle_field_pattern_match(&mut self, lhs: &hir::Pat, res: Res,`
`123`		`- pats: &[source_map::Spanned<hir::FieldPat>]) {`
	`121`	`+ fn handle_field_pattern_match(&mut self, lhs: &hir::Pat, res: Res, pats: &[hir::FieldPat]) {`
`124`	`122`	`let variant = match self.tables.node_type(lhs.hir_id).sty {`
`125`	`123`	`ty::Adt(adt, _) => adt.variant_of_res(res),`
`126`	`124`	`_ => span_bug!(lhs.span, "non-ADT in struct pattern")`
`127`	`125`	`};`
`128`	`126`	`for pat in pats {`
`129`		`- if let PatKind::Wild = pat.node.pat.node {`
	`127`	`+ if let PatKind::Wild = pat.pat.node {`
`130`	`128`	`continue;`
`131`	`129`	`}`
`132`		`- let index = self.tcx.field_index(pat.node.hir_id, self.tables);`
	`130`	`+ let index = self.tcx.field_index(pat.hir_id, self.tables);`
`133`	`131`	`self.insert_def_id(variant.fields[index].did);`
`134`	`132`	`}`
`135`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -418,8 +418,8 @@ fn add_from_pat<'tcx>(ir: &mut IrMaps<'tcx>, pat: &P<hir::Pat>) {`
`418`	`418`	`}`
`419`	`419`	`Struct(_, ref fields, _) => {`
`420`	`420`	`for field in fields {`
`421`		`- if field.node.is_shorthand {`
`422`		`- shorthand_field_ids.insert(field.node.pat.hir_id);`
	`421`	`+ if field.is_shorthand {`
	`422`	`+ shorthand_field_ids.insert(field.pat.hir_id);`
`423`	`423`	`}`
`424`	`424`	`}`
`425`	`425`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1282,11 +1282,11 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {`
`1282`	`1282`	`};`
`1283`	`1283`
`1284`	`1284`	`for fp in field_pats {`
`1285`		`- let field_ty = self.pat_ty_adjusted(&fp.node.pat)?; // see (*2)`
`1286`		`- let f_index = self.tcx.field_index(fp.node.hir_id, self.tables);`
	`1285`	`+ let field_ty = self.pat_ty_adjusted(&fp.pat)?; // see (*2)`
	`1286`	`+ let f_index = self.tcx.field_index(fp.hir_id, self.tables);`
`1287`	`1287`	`let cmt_field = Rc::new(self.cat_field(pat, cmt.clone(), f_index,`
`1288`		`- fp.node.ident, field_ty));`
`1289`		`- self.cat_pattern_(cmt_field, &fp.node.pat, op)?;`
	`1288`	`+ fp.ident, field_ty));`
	`1289`	`+ self.cat_pattern_(cmt_field, &fp.pat, op)?;`
`1290`	`1290`	`}`
`1291`	`1291`	`}`
`1292`	`1292`
Original file line number	Diff line number	Diff line change
`@@ -1207,7 +1207,7 @@ fn resolve_local<'tcx>(`
`1207`	`1207`	`PatKind::Binding(hir::BindingAnnotation::RefMut, ..) => true,`
`1208`	`1208`
`1209`	`1209`	`PatKind::Struct(_, ref field_pats, _) => {`
`1210`		`- field_pats.iter().any(\|fp\| is_binding_pat(&fp.node.pat))`
	`1210`	`+ field_pats.iter().any(\|fp\| is_binding_pat(&fp.pat))`
`1211`	`1211`	`}`
`1212`	`1212`
`1213`	`1213`	`PatKind::Slice(ref pats1, ref pats2, ref pats3) => {`