Remove span from hir::GenericParam.

Author: cjgillot

compiler/rustc_ast_lowering/src/lib.rs

@@ -874,7 +874,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir_id: self.lower_node_id(node_id, span),
             name: hir_name,
             bounds: &[],
-            span,
             pure_wrt_drop: false,
             kind: hir::GenericParamKind::Lifetime { kind },
         }
@@ -1497,7 +1496,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             name: ParamName::Plain(ident),
                             pure_wrt_drop: false,
                             bounds: hir_bounds,
-                            span,
                             kind: hir::GenericParamKind::Type {
                                 default: None,
                                 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait),
@@ -1785,7 +1783,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     self.output_lifetime_params.push(hir::GenericParam {
                         hir_id,
                         name,
-                        span: lifetime.span,
                         pure_wrt_drop: false,
                         bounds: &[],
                         kind: hir::GenericParamKind::Lifetime { kind },
@@ -2359,7 +2356,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         hir::GenericParam {
             hir_id,
             name,
-            span: param.ident.span,
             pure_wrt_drop: self.sess.contains_name(&param.attrs, sym::may_dangle),
             bounds: self.arena.alloc_from_iter(bounds),
             kind,

compiler/rustc_hir/src/hir.rs

@@ -16,7 +16,7 @@ use rustc_macros::HashStable_Generic;
 use rustc_span::source_map::{SourceMap, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{def_id::LocalDefId, BytePos};
-use rustc_span::{MultiSpan, Span, DUMMY_SP};
+use rustc_span::{Span, DUMMY_SP};
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use rustc_target::spec::abi::Abi;
 
@@ -471,7 +471,6 @@ pub struct GenericParam<'hir> {
     pub hir_id: HirId,
     pub name: ParamName,
     pub bounds: GenericBounds<'hir>,
-    pub span: Span,
     pub pure_wrt_drop: bool,
     pub kind: GenericParamKind<'hir>,
 }
@@ -519,14 +518,6 @@ impl Generics<'hir> {
         }
         None
     }
-
-    pub fn spans(&self) -> MultiSpan {
-        if self.params.is_empty() {
-            self.span.into()
-        } else {
-            self.params.iter().map(|p| p.span).collect::<Vec<Span>>().into()
-        }
-    }
 }
 
 /// Synthetic type parameters are converted to another form during lowering; this allows

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -163,7 +163,7 @@ fn msg_span_from_early_bound_and_free_regions(
             if let Some(param) =
                 tcx.hir().get_generics(scope).and_then(|generics| generics.get_named(br.name))
             {
-                sp = param.span;
+                sp = tcx.hir().span(param.hir_id);
             }
             (format!("the lifetime `{}` as defined on", br.name), sp)
         }
@@ -174,7 +174,7 @@ fn msg_span_from_early_bound_and_free_regions(
             if let Some(param) =
                 tcx.hir().get_generics(scope).and_then(|generics| generics.get_named(name))
             {
-                sp = param.span;
+                sp = tcx.hir().span(param.hir_id);
             }
             (format!("the lifetime `{}` as defined on", name), sp)
         }

compiler/rustc_lint/src/builtin.rs

@@ -1487,7 +1487,8 @@ impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
             let suggestion = spans
                 .iter()
                 .map(|sp| {
-                    let start = param.span.between(*sp); // Include the `:` in `T: Bound`.
+                    let param_span = cx.tcx.hir().span(param.hir_id);
+                    let start = param_span.between(*sp); // Include the `:` in `T: Bound`.
                     (start.to(*sp), String::new())
                 })
                 .collect();
@@ -2142,8 +2143,9 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements {
                     infer_static,
                 );
                 bound_count += bound_spans.len();
+                let param_span = cx.tcx.hir().span(param.hir_id);
                 lint_spans.extend(self.consolidate_outlives_bound_spans(
-                    param.span.shrink_to_hi(),
+                    param_span.shrink_to_hi(),
                     &param.bounds,
                     bound_spans,
                 ));

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -129,7 +129,10 @@ pub fn suggest_constraining_type_param(
 
     if def_id == tcx.lang_items().sized_trait() {
         // Type parameters are already `Sized` by default.
-        err.span_label(param.span, &format!("this type parameter needs to be `{}`", constraint));
+        err.span_label(
+            tcx.hir().span(param.hir_id),
+            &format!("this type parameter needs to be `{}`", constraint),
+        );
         return true;
     }
     let mut suggest_restrict = |span| {
@@ -157,7 +160,7 @@ pub fn suggest_constraining_type_param(
         //             |
         //             replace with: `impl Foo + Bar`
 
-        suggest_restrict(param.span.shrink_to_hi());
+        suggest_restrict(tcx.hir().span(param.hir_id).shrink_to_hi());
         return true;
     }
 
@@ -187,7 +190,7 @@ pub fn suggest_constraining_type_param(
             //   fn foo<T>(t: T) { ... }
             //          - help: consider restricting this type parameter with `T: Foo`
             err.span_suggestion_verbose(
-                param.span.shrink_to_hi(),
+                tcx.hir().span(param.hir_id).shrink_to_hi(),
                 &msg_restrict_type,
                 format!(": {}", constraint),
                 Applicability::MachineApplicable,

compiler/rustc_passes/src/check_attr.rs

@@ -843,14 +843,15 @@ impl CheckAttrVisitor<'tcx> {
             match param.kind {
                 hir::GenericParamKind::Const { .. } => {}
                 _ => {
+                    let param_span = self.tcx.hir().span(param.hir_id);
                     self.tcx
                         .sess
                         .struct_span_err(
                             attr.span,
                             "#[rustc_legacy_const_generics] functions must \
                              only have const generics",
                         )
-                        .span_label(param.span, "non-const generic parameter")
+                        .span_label(param_span, "non-const generic parameter")
                         .emit();
                     return false;
                 }
@@ -1219,7 +1220,8 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
 
     fn visit_generic_param(&mut self, generic_param: &'tcx hir::GenericParam<'tcx>) {
         let target = Target::from_generic_param(generic_param);
-        self.check_attributes(generic_param.hir_id, &generic_param.span, target, None);
+        let span = self.tcx.hir().span(generic_param.hir_id);
+        self.check_attributes(generic_param.hir_id, &span, target, None);
         intravisit::walk_generic_param(self, generic_param)
     }
 

compiler/rustc_passes/src/stability.rs

@@ -517,9 +517,10 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
             _ => AnnotationKind::Prohibited,
         };
 
+        let span = self.tcx.hir().span(p.hir_id);
         self.annotate(
             p.hir_id,
-            p.span,
+            span,
             kind,
             InheritDeprecation::No,
             InheritConstStability::No,

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -1670,7 +1670,8 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
                             }
                         )
                     }) {
-                        (param.span.shrink_to_lo(), format!("{}, ", lifetime_ref))
+                        let span = self.tcx.hir().span(param.hir_id);
+                        (span.shrink_to_lo(), format!("{}, ", lifetime_ref))
                     } else {
                         suggests_in_band = true;
                         (generics.span, format!("<{}>", lifetime_ref))
@@ -1754,7 +1755,10 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
             {
                 let (span, span_type) = match &trait_ref.bound_generic_params {
                     [] => (trait_ref.span.shrink_to_lo(), ForLifetimeSpanType::BoundEmpty),
-                    [.., bound] => (bound.span.shrink_to_hi(), ForLifetimeSpanType::BoundTail),
+                    [.., bound] => (
+                        self.tcx.hir().span(bound.hir_id).shrink_to_hi(),
+                        ForLifetimeSpanType::BoundTail,
+                    ),
                 };
                 self.missing_named_lifetime_spots
                     .push(MissingLifetimeSpot::HigherRanked { span, span_type });
@@ -1868,7 +1872,8 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
                                 }
                             )
                         }) {
-                            (param.span.shrink_to_lo(), "'a, ".to_string())
+                            let span = self.tcx.hir().span(param.hir_id);
+                            (span.shrink_to_lo(), "'a, ".to_string())
                         } else {
                             (generics.span, "<'a>".to_string())
                         }

compiler/rustc_resolve/src/late/lifetimes.rs

@@ -505,7 +505,9 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                 self.is_in_fn_syntax = true;
                 let lifetime_span: Option<Span> =
                     c.generic_params.iter().rev().find_map(|param| match param.kind {
-                        GenericParamKind::Lifetime { .. } => Some(param.span),
+                        GenericParamKind::Lifetime { .. } => {
+                            Some(self.tcx.hir().span(param.hir_id))
+                        }
                         _ => None,
                     });
                 let (span, span_type) = if let Some(span) = lifetime_span {
@@ -1073,8 +1075,9 @@ fn shadower_label(span: Span) -> Shadower {
 fn original_lifetime(span: Span) -> Original {
     Original { kind: ShadowKind::Lifetime, span }
 }
-fn shadower_lifetime(param: &hir::GenericParam<'_>) -> Shadower {
-    Shadower { kind: ShadowKind::Lifetime, span: param.span }
+fn shadower_lifetime(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Shadower {
+    let span = tcx.hir().span(param.hir_id);
+    Shadower { kind: ShadowKind::Lifetime, span }
 }
 
 impl ShadowKind {
@@ -1090,7 +1093,7 @@ fn check_mixed_explicit_and_in_band_defs(tcx: TyCtxt<'_>, params: &[hir::Generic
     let lifetime_params: Vec<_> = params
         .iter()
         .filter_map(|param| match param.kind {
-            GenericParamKind::Lifetime { kind, .. } => Some((kind, param.span)),
+            GenericParamKind::Lifetime { kind, .. } => Some((kind, tcx.hir().span(param.hir_id))),
             _ => None,
         })
         .collect();
@@ -1415,18 +1418,21 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                     param.kind,
                     hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::InBand }
                 );
+                let param_span = self.tcx.hir().span(param.hir_id);
                 if in_band {
-                    Some(param.span)
+                    Some(param_span)
                 } else if generics.params.len() == 1 {
                     // if sole lifetime, remove the entire `<>` brackets
                     Some(generics.span)
                 } else {
                     // if removing within `<>` brackets, we also want to
                     // delete a leading or trailing comma as appropriate
                     if i >= generics.params.len() - 1 {
-                        Some(generics.params[i - 1].span.shrink_to_hi().to(param.span))
+                        let generic_span = self.tcx.hir().span(generics.params[i - 1].hir_id);
+                        Some(generic_span.shrink_to_hi().to(param_span))
                     } else {
-                        Some(param.span.to(generics.params[i + 1].span.shrink_to_lo()))
+                        let generic_span = self.tcx.hir().span(generics.params[i + 1].hir_id);
+                        Some(param_span.to(generic_span.shrink_to_lo()))
                     }
                 }
             } else {
@@ -1583,7 +1589,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                             hir_lifetime.name.ident(),
                         )),
                         Node::GenericParam(param) => {
-                            Some((param.hir_id, param.span, param.name.ident()))
+                            let span = self.tcx.hir().span(param.hir_id);
+                            Some((param.hir_id, span, param.name.ident()))
                         }
                         _ => None,
                     } {
@@ -1640,7 +1647,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                             hir_lifetime.name.ident(),
                         )),
                         Node::GenericParam(param) => {
-                            Some((param.hir_id, param.span, param.name.ident()))
+                            let span = self.tcx.hir().span(param.hir_id);
+                            Some((param.hir_id, span, param.name.ident()))
                         }
                         _ => None,
                     } {
@@ -2580,33 +2588,33 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
             if let hir::ParamName::Plain(_) = lifetime_i_name {
                 let name = lifetime_i_name.ident().name;
                 if name == kw::UnderscoreLifetime || name == kw::StaticLifetime {
+                    let span_i = self.tcx.hir().span(lifetime_i.hir_id);
                     let mut err = struct_span_err!(
                         self.tcx.sess,
-                        lifetime_i.span,
+                        span_i,
                         E0262,
                         "invalid lifetime parameter name: `{}`",
                         lifetime_i.name.ident(),
                     );
-                    err.span_label(
-                        lifetime_i.span,
-                        format!("{} is a reserved lifetime name", name),
-                    );
+                    err.span_label(span_i, format!("{} is a reserved lifetime name", name));
                     err.emit();
                 }
             }
 
             // It is a hard error to shadow a lifetime within the same scope.
             for (lifetime_j, lifetime_j_name) in lifetimes.iter().skip(i + 1) {
                 if lifetime_i_name == lifetime_j_name {
+                    let span_i = self.tcx.hir().span(lifetime_i.hir_id);
+                    let span_j = self.tcx.hir().span(lifetime_j.hir_id);
                     struct_span_err!(
                         self.tcx.sess,
-                        lifetime_j.span,
+                        span_j,
                         E0263,
                         "lifetime name `{}` declared twice in the same scope",
                         lifetime_j.name.ident()
                     )
-                    .span_label(lifetime_j.span, "declared twice")
-                    .span_label(lifetime_i.span, "previous declaration here")
+                    .span_label(span_j, "declared twice")
+                    .span_label(span_i, "previous declaration here")
                     .emit();
                 }
             }
@@ -2623,10 +2631,11 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                         ),
                         hir::LifetimeName::Static => {
                             self.insert_lifetime(lt, Region::Static);
+                            let span_i = self.tcx.hir().span(lifetime_i.hir_id);
                             self.tcx
                                 .sess
                                 .struct_span_warn(
-                                    lifetime_i.span.to(lt.span),
+                                    span_i.to(lt.span),
                                     &format!(
                                         "unnecessary lifetime parameter `{}`",
                                         lifetime_i.name.ident(),
@@ -2670,7 +2679,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                     self.tcx,
                     label.name,
                     original_label(label.span),
-                    shadower_lifetime(&param),
+                    shadower_lifetime(self.tcx, &param),
                 );
                 return;
             }
@@ -2697,7 +2706,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                             self.tcx,
                             param.name.ident().name,
                             original_lifetime(self.tcx.hir().span(hir_id)),
-                            shadower_lifetime(&param),
+                            shadower_lifetime(self.tcx, &param),
                         );
                         return;
                     }

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -1739,7 +1739,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
             None => return,
         };
         for param in generics.params {
-            if param.span != span
+            let param_span = self.tcx.hir().span(param.hir_id);
+            if param_span != span
                 || param.bounds.iter().any(|bound| {
                     bound.trait_ref().and_then(|trait_ref| trait_ref.trait_def_id())
                         == self.tcx.lang_items().sized_trait()
@@ -1769,9 +1770,9 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                     };
                     visitor.visit_item(item);
                     if !visitor.invalid_spans.is_empty() {
-                        let mut multispan: MultiSpan = param.span.into();
+                        let mut multispan: MultiSpan = param_span.into();
                         multispan.push_span_label(
-                            param.span,
+                            param_span,
                             format!("this could be changed to `{}: ?Sized`...", param.name.ident()),
                         );
                         for sp in visitor.invalid_spans {