Remove GenericArg::span.

Author: cjgillot

compiler/rustc_ast_lowering/src/path.rs

@@ -266,10 +266,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             generic_args.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)));
         let first_generic_span = generic_args
             .args
-            .iter()
-            .map(|a| a.span())
-            .chain(generic_args.bindings.iter().map(|b| b.span))
-            .next();
+            .first()
+            .map(|a| self.spans[a.id()])
+            .or_else(|| generic_args.bindings.first().map(|b| b.span));
         if !generic_args.parenthesized && !has_lifetimes {
             generic_args.args = self
                 .elided_path_lifetimes(

compiler/rustc_hir/src/hir.rs

@@ -256,14 +256,6 @@ pub enum GenericArg<'hir> {
 }
 
 impl GenericArg<'_> {
-    pub fn span(&self) -> Span {
-        match self {
-            GenericArg::Lifetime(l) => l.span,
-            GenericArg::Type(t) => t.span,
-            GenericArg::Const(c) => c.span,
-        }
-    }
-
     pub fn id(&self) -> HirId {
         match self {
             GenericArg::Lifetime(l) => l.hir_id,

compiler/rustc_mir/src/borrow_check/diagnostics/region_name.rs

@@ -638,7 +638,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                     // doesn't happen, even in erroneous
                     // programs. Else we should use delay-span-bug.
                     span_bug!(
-                        hir_arg.span(),
+                        self.infcx.tcx.hir().span(hir_arg.id()),
                         "unmatched subst and hir arg: found {:?} vs {:?}",
                         kind,
                         hir_arg,

compiler/rustc_typeck/src/astconv/generics.rs

@@ -27,9 +27,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         help: Option<&str>,
     ) {
         let sess = tcx.sess;
+        let arg_span = tcx.hir().span(arg.id());
         let mut err = struct_span_err!(
             sess,
-            arg.span(),
+            arg_span,
             E0747,
             "{} provided when a {} was expected",
             arg.descr(),
@@ -49,8 +50,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 GenericParamDefKind::Const { .. },
             ) => {
                 let suggestions = vec![
-                    (arg.span().shrink_to_lo(), String::from("{ ")),
-                    (arg.span().shrink_to_hi(), String::from(" }")),
+                    (arg_span.shrink_to_lo(), String::from("{ ")),
+                    (arg_span.shrink_to_hi(), String::from(" }")),
                 ];
                 err.multipart_suggestion(
                     "if this generic argument was intended as a const parameter, \
@@ -66,7 +67,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 let snippet = sess.source_map().span_to_snippet(tcx.hir().span(len.hir_id));
                 if let Ok(snippet) = snippet {
                     err.span_suggestion(
-                        arg.span(),
+                        arg_span,
                         "array type provided where a `usize` was expected, try",
                         format!("{{ {} }}", snippet),
                         Applicability::MaybeIncorrect,
@@ -450,7 +451,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 let (spans, labels): (Vec<Span>, Vec<String>) = args.args
                     [offset + permitted..offset + provided]
                     .iter()
-                    .map(|arg| (arg.span(), format!("unexpected {} argument", arg.short_descr())))
+                    .map(|arg| {
+                        (
+                            tcx.hir().span(arg.id()),
+                            format!("unexpected {} argument", arg.short_descr()),
+                        )
+                    })
                     .unzip();
                 unexpected_spans.extend(spans.clone());
                 (spans, labels)
@@ -553,7 +559,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 .args
                 .iter()
                 .filter_map(|arg| match arg {
-                    GenericArg::Type(_) | GenericArg::Const(_) => Some(arg.span()),
+                    GenericArg::Type(_) | GenericArg::Const(_) => Some(tcx.hir().span(arg.id())),
                     _ => None,
                 })
                 .collect::<Vec<_>>();
@@ -599,7 +605,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             let msg = "cannot specify lifetime arguments explicitly \
                        if late bound lifetime parameters are present";
             let note = "the late bound lifetime parameter is introduced here";
-            let span = args.args[0].span();
+            let span = tcx.hir().span(args.args[0].id());
             if position == GenericArgPosition::Value
                 && arg_counts.lifetimes != param_counts.lifetimes
             {

compiler/rustc_typeck/src/astconv/mod.rs

@@ -401,10 +401,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     }
                     (&GenericParamDefKind::Type { has_default, .. }, GenericArg::Type(ty)) => {
                         if has_default {
+                            let arg_id = arg.id();
                             tcx.check_optional_stability(
                                 param.def_id,
-                                Some(arg.id()),
-                                arg.span(),
+                                Some(arg_id),
+                                tcx.hir().span(arg_id),
                                 |_, _| {
                                     // Default generic parameters may not be marked
                                     // with stability attributes, i.e. when the

compiler/rustc_typeck/src/check/fn_ctxt/checks.rs

@@ -129,10 +129,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .and_then(|args| args.args.iter().last())
                         // Account for `foo.bar::<T>()`.
                         .map(|arg| {
+                            let arg_span = tcx.hir().span(arg.id());
                             // Skip the closing `>`.
                             tcx.sess
                                 .source_map()
-                                .next_point(tcx.sess.source_map().next_point(arg.span()))
+                                .next_point(tcx.sess.source_map().next_point(arg_span))
                         })
                         .unwrap_or(*span),
                     &args[1..], // Skip the receiver.