Remove span from hir::StructField.

cjgillot · cjgillot · commit 0bf0ea288056 · 2020-06-23T09:49:11.000+02:00
diff --git a/src/librustc_ast_lowering/item.rs b/src/librustc_ast_lowering/item.rs
@@ -739,7 +739,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
             self.lower_ty(&f.ty, ImplTraitContext::disallowed())
         };
         hir::StructField {
-            span: f.span,
             hir_id: self.lower_node_id(f.id, f.span),
             ident: match f.ident {
                 Some(ident) => ident,
diff --git a/src/librustc_hir/hir.rs b/src/librustc_hir/hir.rs
@@ -2382,7 +2382,6 @@ impl VisibilityKind<'_> {
 
 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)]
 pub struct StructField<'hir> {
-    pub span: Span,
     #[stable_hasher(project(name))]
     pub ident: Ident,
     pub vis: Visibility<'hir>,
diff --git a/src/librustc_hir_pretty/lib.rs b/src/librustc_hir_pretty/lib.rs
@@ -897,7 +897,8 @@ impl<'a> State<'a> {
                 if let hir::VariantData::Tuple(..) = struct_def {
                     self.popen();
                     self.commasep(Inconsistent, struct_def.fields(), |s, field| {
-                        s.maybe_print_comment(field.span.lo());
+                        let span = s.span(field.hir_id);
+                        s.maybe_print_comment(span.lo());
                         s.print_outer_attributes(&field.attrs);
                         s.print_visibility(&field.vis);
                         s.print_type(&field.ty)
@@ -918,8 +919,9 @@ impl<'a> State<'a> {
                 self.hardbreak_if_not_bol();
 
                 for field in struct_def.fields() {
+                    let span = self.span(field.hir_id);
                     self.hardbreak_if_not_bol();
-                    self.maybe_print_comment(field.span.lo());
+                    self.maybe_print_comment(span.lo());
                     self.print_outer_attributes(&field.attrs);
                     self.print_visibility(&field.vis);
                     self.print_ident(field.ident);
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -136,7 +136,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers {
             hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => {
                 for struct_field in struct_def.fields() {
                     let def_id = cx.tcx.hir().local_def_id(struct_field.hir_id);
-                    self.check_heap_type(cx, struct_field.span, cx.tcx.type_of(def_id));
+                    let span = cx.tcx.hir().span(struct_field.hir_id);
+                    self.check_heap_type(cx, span, cx.tcx.type_of(def_id));
                 }
             }
             _ => (),
@@ -505,14 +506,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
 
     fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, sf: &hir::StructField<'_>) {
         if !sf.is_positional() {
-            self.check_missing_docs_attrs(
-                cx,
-                Some(sf.hir_id),
-                &sf.attrs,
-                sf.span,
-                "a",
-                "struct field",
-            )
+            let span = cx.tcx.hir().span(sf.hir_id);
+            self.check_missing_docs_attrs(cx, Some(sf.hir_id), &sf.attrs, span, "a", "struct field")
         }
     }
 
@@ -1025,7 +1020,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub {
     }
 
     fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField<'_>) {
-        self.perform_lint(cx, "field", field.hir_id, &field.vis, field.span, false);
+        let span = cx.tcx.hir().span(field.hir_id);
+        self.perform_lint(cx, "field", field.hir_id, &field.vis, span, false);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem<'_>) {
diff --git a/src/librustc_middle/hir/map/collector.rs b/src/librustc_middle/hir/map/collector.rs
@@ -536,7 +536,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_struct_field(&mut self, field: &'hir StructField<'hir>) {
-        self.insert(field.span, field.hir_id, Node::Field(field));
+        self.insert(DUMMY_SP, field.hir_id, Node::Field(field));
         self.with_parent(field.hir_id, |this| {
             intravisit::walk_struct_field(this, field);
         });
diff --git a/src/librustc_passes/dead.rs b/src/librustc_passes/dead.rs
@@ -633,7 +633,8 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> {
 
     fn visit_struct_field(&mut self, field: &'tcx hir::StructField<'tcx>) {
         if self.should_warn_about_field(&field) {
-            self.warn_dead_code(field.hir_id, field.span, field.ident.name, "read");
+            let span = self.tcx.hir().span(field.hir_id);
+            self.warn_dead_code(field.hir_id, span, field.ident.name, "read");
         }
         intravisit::walk_struct_field(self, field);
     }
diff --git a/src/librustc_passes/stability.rs b/src/librustc_passes/stability.rs
@@ -316,7 +316,8 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_struct_field(&mut self, s: &'tcx StructField<'tcx>) {
-        self.annotate(s.hir_id, &s.attrs, s.span, AnnotationKind::Required, |v| {
+        let span = self.tcx.hir().span(s.hir_id);
+        self.annotate(s.hir_id, &s.attrs, span, AnnotationKind::Required, |v| {
             intravisit::walk_struct_field(v, s);
         });
     }
@@ -391,7 +392,8 @@ impl<'a, 'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'a, 'tcx> {
     }
 
     fn visit_struct_field(&mut self, s: &'tcx StructField<'tcx>) {
-        self.check_missing_stability(s.hir_id, s.span);
+        let span = self.tcx.hir().span(s.hir_id);
+        self.check_missing_stability(s.hir_id, span);
         intravisit::walk_struct_field(self, s);
     }
 
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -1326,10 +1326,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .iter()
             .map(|field| {
                 let field_ty = self.tcx.type_of(self.tcx.hir().local_def_id(field.hir_id));
-                let field_ty = self.normalize_associated_types_in(field.span, &field_ty);
+                let span = self.tcx.hir().span(field.hir_id);
+                let field_ty = self.normalize_associated_types_in(span, &field_ty);
                 let field_ty = self.resolve_vars_if_possible(&field_ty);
                 debug!("non_enum_variant: type of field {:?} is {:?}", field, field_ty);
-                AdtField { ty: field_ty, span: field.span }
+                AdtField { ty: field_ty, span }
             })
             .collect();
         AdtVariant { fields, explicit_discr: None }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -819,20 +819,15 @@ fn convert_variant(
         .iter()
         .map(|f| {
             let fid = tcx.hir().local_def_id(f.hir_id);
+            let span = tcx.hir().span(f.hir_id);
             let dup_span = seen_fields.get(&f.ident.normalize_to_macros_2_0()).cloned();
             if let Some(prev_span) = dup_span {
-                struct_span_err!(
-                    tcx.sess,
-                    f.span,
-                    E0124,
-                    "field `{}` is already declared",
-                    f.ident
-                )
-                .span_label(f.span, "field already declared")
-                .span_label(prev_span, format!("`{}` first declared here", f.ident))
-                .emit();
+                struct_span_err!(tcx.sess, span, E0124, "field `{}` is already declared", f.ident)
+                    .span_label(span, "field already declared")
+                    .span_label(prev_span, format!("`{}` first declared here", f.ident))
+                    .emit();
             } else {
-                seen_fields.insert(f.ident.normalize_to_macros_2_0(), f.span);
+                seen_fields.insert(f.ident.normalize_to_macros_2_0(), span);
             }
 
             ty::FieldDef {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1736,11 +1736,12 @@ impl<'tcx> Clean<Constant> for ty::Const<'tcx> {
 impl Clean<Item> for hir::StructField<'_> {
     fn clean(&self, cx: &DocContext<'_>) -> Item {
         let local_did = cx.tcx.hir().local_def_id(self.hir_id);
+        let span = cx.tcx.hir().span(self.hir_id);
 
         Item {
             name: Some(self.ident.name).clean(cx),
             attrs: self.attrs.clean(cx),
-            source: self.span.clean(cx),
+            source: span.clean(cx),
             visibility: self.vis.clean(cx),
             stability: get_stability(cx, local_did.to_def_id()),
             deprecation: get_deprecation(cx, local_did.to_def_id()),
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
@@ -1015,9 +1015,15 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx>
     }
 
     fn visit_struct_field(&mut self, f: &'hir hir::StructField) {
-        self.visit_testable(f.ident.to_string(), &f.attrs, f.hir_id, f.span, |this| {
-            intravisit::walk_struct_field(this, f);
-        });
+        self.visit_testable(
+            f.ident.to_string(),
+            &f.attrs,
+            f.hir_id,
+            self.map.span(f.hir_id),
+            |this| {
+                intravisit::walk_struct_field(this, f);
+            },
+        );
     }
 
     fn visit_macro_def(&mut self, macro_def: &'hir hir::MacroDef) {
diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs
@@ -193,7 +193,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
 
     fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, sf: &'tcx hir::StructField<'_>) {
         if !sf.is_positional() {
-            self.check_missing_docs_attrs(cx, &sf.attrs, sf.span, "a struct field");
+            self.check_missing_docs_attrs(cx, &sf.attrs, cx.tcx.hir().span(sf.hir_id), "a struct field");
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers {`
`136`	`136`	`hir::ItemKind::Struct(ref struct_def, _) \| hir::ItemKind::Union(ref struct_def, _) => {`
`137`	`137`	`for struct_field in struct_def.fields() {`
`138`	`138`	`let def_id = cx.tcx.hir().local_def_id(struct_field.hir_id);`
`139`		`- self.check_heap_type(cx, struct_field.span, cx.tcx.type_of(def_id));`
	`139`	`+ let span = cx.tcx.hir().span(struct_field.hir_id);`
	`140`	`+ self.check_heap_type(cx, span, cx.tcx.type_of(def_id));`
`140`	`141`	`}`
`141`	`142`	`}`
`142`	`143`	`_ => (),`
`@@ -505,14 +506,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {`
`505`	`506`
`506`	`507`	`fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, sf: &hir::StructField<'_>) {`
`507`	`508`	`if !sf.is_positional() {`
`508`		`- self.check_missing_docs_attrs(`
`509`		`- cx,`
`510`		`- Some(sf.hir_id),`
`511`		`- &sf.attrs,`
`512`		`- sf.span,`
`513`		`- "a",`
`514`		`- "struct field",`
`515`		`- )`
	`509`	`+ let span = cx.tcx.hir().span(sf.hir_id);`
	`510`	`+ self.check_missing_docs_attrs(cx, Some(sf.hir_id), &sf.attrs, span, "a", "struct field")`
`516`	`511`	`}`
`517`	`512`	`}`
`518`	`513`
`@@ -1025,7 +1020,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub {`
`1025`	`1020`	`}`
`1026`	`1021`
`1027`	`1022`	`fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField<'_>) {`
`1028`		`- self.perform_lint(cx, "field", field.hir_id, &field.vis, field.span, false);`
	`1023`	`+ let span = cx.tcx.hir().span(field.hir_id);`
	`1024`	`+ self.perform_lint(cx, "field", field.hir_id, &field.vis, span, false);`
`1029`	`1025`	`}`
`1030`	`1026`
`1031`	`1027`	`fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem<'_>) {`
Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {`
`536`	`536`	`}`
`537`	`537`
`538`	`538`	`fn visit_struct_field(&mut self, field: &'hir StructField<'hir>) {`
`539`		`- self.insert(field.span, field.hir_id, Node::Field(field));`
	`539`	`+ self.insert(DUMMY_SP, field.hir_id, Node::Field(field));`
`540`	`540`	`self.with_parent(field.hir_id, \|this\| {`
`541`	`541`	`intravisit::walk_struct_field(this, field);`
`542`	`542`	`});`
Original file line number	Diff line number	Diff line change
`@@ -633,7 +633,8 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> {`
`633`	`633`
`634`	`634`	`fn visit_struct_field(&mut self, field: &'tcx hir::StructField<'tcx>) {`
`635`	`635`	`if self.should_warn_about_field(&field) {`
`636`		`- self.warn_dead_code(field.hir_id, field.span, field.ident.name, "read");`
	`636`	`+ let span = self.tcx.hir().span(field.hir_id);`
	`637`	`+ self.warn_dead_code(field.hir_id, span, field.ident.name, "read");`
`637`	`638`	`}`
`638`	`639`	`intravisit::walk_struct_field(self, field);`
`639`	`640`	`}`
Original file line number	Diff line number	Diff line change
`@@ -316,7 +316,8 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {`
`316`	`316`	`}`
`317`	`317`
`318`	`318`	`fn visit_struct_field(&mut self, s: &'tcx StructField<'tcx>) {`
`319`		`- self.annotate(s.hir_id, &s.attrs, s.span, AnnotationKind::Required, \|v\| {`
	`319`	`+ let span = self.tcx.hir().span(s.hir_id);`
	`320`	`+ self.annotate(s.hir_id, &s.attrs, span, AnnotationKind::Required, \|v\| {`
`320`	`321`	`intravisit::walk_struct_field(v, s);`
`321`	`322`	`});`
`322`	`323`	`}`
`@@ -391,7 +392,8 @@ impl<'a, 'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'a, 'tcx> {`
`391`	`392`	`}`
`392`	`393`
`393`	`394`	`fn visit_struct_field(&mut self, s: &'tcx StructField<'tcx>) {`
`394`		`- self.check_missing_stability(s.hir_id, s.span);`
	`395`	`+ let span = self.tcx.hir().span(s.hir_id);`
	`396`	`+ self.check_missing_stability(s.hir_id, span);`
`395`	`397`	`intravisit::walk_struct_field(self, s);`
`396`	`398`	`}`
`397`	`399`