Remove span from hir::FieldPat.

Author: cjgillot

compiler/rustc_ast_lowering/src/expr.rs

@@ -1122,7 +1122,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         ident: f.ident,
                         pat,
                         is_shorthand: f.is_shorthand,
-                        span: f.span,
                     }
                 }));
                 let qpath = self.lower_qpath(

compiler/rustc_ast_lowering/src/lib.rs

@@ -2627,7 +2627,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             ident: Ident::new(sym::integer(0), span),
             is_shorthand: false,
             pat,
-            span,
         };
         arena_vec![self; field]
     }

compiler/rustc_ast_lowering/src/pat.rs

@@ -61,7 +61,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             ident: f.ident,
                             pat: self.lower_pat(&f.pat),
                             is_shorthand: f.is_shorthand,
-                            span: f.span,
                         }));
                         break hir::PatKind::Struct(qpath, fs, etc);
                     }

compiler/rustc_hir/src/hir.rs

@@ -884,7 +884,6 @@ pub struct FieldPat<'hir> {
     /// The pattern the field is destructured to.
     pub pat: &'hir Pat<'hir>,
     pub is_shorthand: bool,
-    pub span: Span,
 }
 
 /// Explicit binding annotations given in the HIR for a binding. Note

compiler/rustc_lint/src/builtin.rs

@@ -248,7 +248,8 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns {
                 if fieldpat.is_shorthand {
                     continue;
                 }
-                if fieldpat.span.from_expansion() {
+                let fieldpat_span = cx.tcx.hir().span(fieldpat.hir_id);
+                if fieldpat_span.from_expansion() {
                     // Don't lint if this is a macro expansion: macro authors
                     // shouldn't have to worry about this kind of style issue
                     // (Issue #49588)
@@ -258,7 +259,7 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns {
                     if cx.tcx.find_field_index(ident, &variant)
                         == Some(cx.tcx.field_index(fieldpat.hir_id, cx.typeck_results()))
                     {
-                        cx.struct_span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span, |lint| {
+                        cx.struct_span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat_span, |lint| {
                             let mut err = lint
                                 .build(&format!("the `{}:` in this pattern is redundant", ident));
                             let binding = match binding_annot {
@@ -273,7 +274,7 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns {
                                 ident.to_string()
                             };
                             err.span_suggestion(
-                                fieldpat.span,
+                                fieldpat_span,
                                 "use shorthand field pattern",
                                 ident,
                                 Applicability::MachineApplicable,

compiler/rustc_privacy/src/lib.rs

@@ -1101,7 +1101,8 @@ impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> {
             for field in fields {
                 let use_ctxt = field.ident.span;
                 let index = self.tcx.field_index(field.hir_id, self.typeck_results());
-                self.check_field(use_ctxt, field.span, adt, &variant.fields[index], false);
+                let field_span = self.tcx.hir().span(field.hir_id);
+                self.check_field(use_ctxt, field_span, adt, &variant.fields[index], false);
             }
         }
 

compiler/rustc_typeck/src/check/pat.rs

@@ -1179,7 +1179,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut inexistent_fields = vec![];
         // Typecheck each field.
         for field in fields {
-            let span = field.span;
+            let span = tcx.hir().span(field.hir_id);
             let ident = tcx.adjust_ident(field.ident, variant.def_id);
             let field_ty = match used_fields.entry(ident) {
                 Occupied(occupied) => {
@@ -1537,8 +1537,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .struct_span_err(pat.span, "pattern requires `..` due to inaccessible fields");
 
         if let Some(field) = fields.last() {
+            let field_span = self.tcx.hir().span(field.hir_id);
             err.span_suggestion_verbose(
-                field.span.shrink_to_hi(),
+                field_span.shrink_to_hi(),
                 "ignore the inaccessible and unused fields",
                 ", ..".to_string(),
                 Applicability::MachineApplicable,
@@ -1606,7 +1607,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             [.., field] => {
                 // Account for last field having a trailing comma or parse recovery at the tail of
                 // the pattern to avoid invalid suggestion (#78511).
-                let tail = field.span.shrink_to_hi().with_hi(pat.span.hi());
+                let field_span = self.tcx.hir().span(field.hir_id);
+                let pat_span = self.tcx.hir().span(pat.hir_id);
+                let tail = field_span.shrink_to_hi().with_hi(pat_span.hi());
                 match &pat.kind {
                     PatKind::Struct(..) => (", ", " }", tail),
                     _ => return err,