Remove Span from hir::Ty.

Author: cjgillot

compiler/rustc_ast_lowering/src/expr.rs

@@ -655,7 +655,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         // Resume argument type. We let the compiler infer this to simplify the lowering. It is
         // fully constrained by `future::from_generator`.
-        let input_ty = hir::Ty { hir_id: self.next_id(span), kind: hir::TyKind::Infer, span };
+        let input_ty = hir::Ty { hir_id: self.next_id(span), kind: hir::TyKind::Infer };
 
         // The closure/generator `FnDecl` takes a single (resume) argument of type `input_ty`.
         let decl = self.arena.alloc(hir::FnDecl {

compiler/rustc_ast_lowering/src/lib.rs

@@ -1346,7 +1346,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn ty(&mut self, span: Span, kind: hir::TyKind<'hir>) -> hir::Ty<'hir> {
-        hir::Ty { hir_id: self.next_id(span), kind, span }
+        hir::Ty { hir_id: self.next_id(span), kind }
     }
 
     fn ty_tup(&mut self, span: Span, tys: &'hir [hir::Ty<'hir>]) -> hir::Ty<'hir> {
@@ -1543,7 +1543,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
         };
 
-        hir::Ty { kind, span: t.span, hir_id: self.lower_node_id(t.id, t.span) }
+        hir::Ty { kind, hir_id: self.lower_node_id(t.id, t.span) }
     }
 
     fn lower_opaque_impl_trait(
@@ -2706,7 +2706,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             _ => hir::TyKind::Path(qpath),
         };
 
-        hir::Ty { hir_id, kind, span }
+        hir::Ty { hir_id, kind }
     }
 
     /// Invoked to create the lifetime argument for a type `&T`

compiler/rustc_ast_lowering/src/path.rs

@@ -409,7 +409,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 FnRetTy::Default(_) => this.arena.alloc(this.ty_tup(*span, &[])),
             };
             let args = smallvec![GenericArg::Type(this.ty_tup(*inputs_span, inputs))];
-            let binding = this.output_ty_binding(output_ty.span, output_ty);
+            let binding = this.output_ty_binding(this.spans[output_ty.hir_id], output_ty);
             (
                 GenericArgsCtor { args, bindings: arena_vec![this; binding], parenthesized: true },
                 false,

compiler/rustc_hir/src/hir.rs

@@ -1793,10 +1793,10 @@ impl<'hir> QPath<'hir> {
 
     /// Returns the span of the qself of this `QPath`. For example, `()` in
     /// `<() as Trait>::method`.
-    pub fn qself_span(&self) -> Span {
+    pub fn qself_span(&self, get_span: impl Fn(HirId) -> Span) -> Span {
         match *self {
             QPath::Resolved(_, path) => path.span,
-            QPath::TypeRelative(qself, _) => qself.span,
+            QPath::TypeRelative(qself, _) => get_span(qself.hir_id),
             QPath::LangItem(_, span) => span,
         }
     }
@@ -2151,7 +2151,6 @@ impl TypeBinding<'_> {
 pub struct Ty<'hir> {
     pub hir_id: HirId,
     pub kind: TyKind<'hir>,
-    pub span: Span,
 }
 
 /// Not represented directly in the AST; referred to by name through a `ty_path`.
@@ -2476,10 +2475,10 @@ pub enum FnRetTy<'hir> {
 }
 
 impl FnRetTy<'_> {
-    pub fn span(&self) -> Span {
+    pub fn span(&self, get_span: impl Fn(HirId) -> Span) -> Span {
         match *self {
             Self::DefaultReturn(span) => span,
-            Self::Return(ref ty) => ty.span,
+            Self::Return(ref ty) => get_span(ty.hir_id),
         }
     }
 }
@@ -3038,7 +3037,7 @@ mod size_asserts {
     rustc_data_structures::static_assert_size!(super::Expr<'static>, 64);
     rustc_data_structures::static_assert_size!(super::Pat<'static>, 80);
     rustc_data_structures::static_assert_size!(super::QPath<'static>, 24);
-    rustc_data_structures::static_assert_size!(super::Ty<'static>, 72);
+    rustc_data_structures::static_assert_size!(super::Ty<'static>, 64);
 
     rustc_data_structures::static_assert_size!(super::Item<'static>, 176);
     rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 120);

compiler/rustc_hir_pretty/src/lib.rs

@@ -381,7 +381,7 @@ impl<'a> State<'a> {
     }
 
     pub fn print_type(&mut self, ty: &hir::Ty<'_>) {
-        self.maybe_print_comment(ty.span.lo());
+        self.maybe_print_comment(self.span(ty.hir_id).lo());
         self.ibox(0);
         match ty.kind {
             hir::TyKind::Slice(ref ty) => {
@@ -2205,7 +2205,7 @@ impl<'a> State<'a> {
         match decl.output {
             hir::FnRetTy::Return(ref ty) => {
                 self.print_type(&ty);
-                self.maybe_print_comment(ty.span.lo())
+                self.maybe_print_comment(self.span(ty.hir_id).lo())
             }
             hir::FnRetTy::DefaultReturn(..) => unreachable!(),
         }
@@ -2397,7 +2397,7 @@ impl<'a> State<'a> {
         self.end();
 
         if let hir::FnRetTy::Return(ref output) = decl.output {
-            self.maybe_print_comment(output.span.lo())
+            self.maybe_print_comment(self.span(output.hir_id).lo())
         }
     }
 

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

@@ -181,7 +181,7 @@ fn msg_span_from_early_bound_and_free_regions(
         ty::ReFree(ref fr) => match fr.bound_region {
             ty::BrAnon(idx) => {
                 if let Some((ty, _)) = find_anon_type(tcx, region, &fr.bound_region) {
-                    ("the anonymous lifetime defined on".to_string(), ty.span)
+                    ("the anonymous lifetime defined on".to_string(), tcx.hir().span(ty.hir_id))
                 } else {
                     (
                         format!("the anonymous lifetime #{} defined on", idx + 1),

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

@@ -214,6 +214,7 @@ impl UseDiagnostic<'_> {
 
 /// Suggest giving an appropriate return type to a closure expression.
 fn closure_return_type_suggestion(
+    tcx: TyCtxt<'_>,
     err: &mut DiagnosticBuilder<'_>,
     output: &FnRetTy<'_>,
     body: &Body<'_>,
@@ -224,9 +225,11 @@ fn closure_return_type_suggestion(
         _ => ("", ""),
     };
     let suggestion = match body.value.kind {
-        ExprKind::Block(..) => vec![(output.span(), format!("{}{}{}", arrow, ret, post))],
+        ExprKind::Block(..) => {
+            vec![(output.span(|id| tcx.hir().span(id)), format!("{}{}{}", arrow, ret, post))]
+        }
         _ => vec![
-            (output.span(), format!("{}{}{}{{ ", arrow, ret, post)),
+            (output.span(|id| tcx.hir().span(id)), format!("{}{}{}{{ ", arrow, ret, post)),
             (body.value.span.shrink_to_hi(), " }".to_string()),
         ],
     };
@@ -554,6 +557,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 
                 if let Some((decl, body_id)) = closure_decl_and_body_id {
                     closure_return_type_suggestion(
+                        self.tcx,
                         &mut err,
                         &decl.output,
                         self.tcx.hir().body(body_id),

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs

@@ -103,6 +103,8 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
             None => String::new(),
         };
 
+        let ty_sub_span = self.tcx().hir().span(ty_sub.hir_id);
+        let ty_sup_span = self.tcx().hir().span(ty_sup.hir_id);
         let (span_1, span_2, main_label, span_label, future_return_type) =
             match (sup_is_ret_type, sub_is_ret_type) {
                 (None, None) => {
@@ -117,7 +119,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                             format!("...but data{} flows{} here", span_label_var1, span_label_var2),
                         )
                     };
-                    (ty_sup.span, ty_sub.span, main_label_1, span_label_1, None)
+                    (ty_sup_span, ty_sub_span, main_label_1, span_label_1, None)
                 }
 
                 (Some(ret_span), _) => {
@@ -129,7 +131,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                     };
 
                     (
-                        ty_sub.span,
+                        ty_sub_span,
                         ret_span,
                         format!(
                             "this parameter and the {} are declared with different lifetimes...",
@@ -148,7 +150,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                     };
 
                     (
-                        ty_sup.span,
+                        ty_sup_span,
                         ret_span,
                         format!(
                             "this parameter and the {} are declared with different lifetimes...",
@@ -167,11 +169,12 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         e.span_label(span, span_label);
 
         if let Some(t) = future_return_type {
+            let t_span = self.tcx().hir().span(t.hir_id);
             let snip = self
                 .tcx()
                 .sess
                 .source_map()
-                .span_to_snippet(t.span)
+                .span_to_snippet(t_span)
                 .ok()
                 .and_then(|s| match (&t.kind, s.as_str()) {
                     (rustc_hir::TyKind::Tup(&[]), "") => Some("()".to_string()),
@@ -181,7 +184,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 .unwrap_or("{unnamed_type}".to_string());
 
             e.span_label(
-                t.span,
+                t_span,
                 &format!("this `async fn` implicitly returns an `impl Future<Output = {}>`", snip),
             );
         }

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/named_anon_conflict.rs

@@ -86,7 +86,9 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
 
                 debug!("try_report_named_anon_conflict: ret ty {:?}", ty);
                 if sub == &ty::ReStatic
-                    && v.0.into_iter().any(|t| t.span.desugaring_kind().is_none())
+                    && v.0
+                        .into_iter()
+                        .any(|t| self.tcx().hir().span(t.hir_id).desugaring_kind().is_none())
                 {
                     // If the failure is due to a `'static` requirement coming from a `dyn` or
                     // `impl` Trait that *isn't* caused by `async fn` desugaring, handle this case

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -225,7 +225,8 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         let add_static_bound = "alternatively, add an explicit `'static` bound to this reference";
         let plus_lt = format!(" + {}", lifetime_name);
         for fn_return in fn_returns {
-            if fn_return.span.desugaring_kind().is_some() {
+            let fn_return_span = self.tcx().hir().span(fn_return.hir_id);
+            if fn_return_span.desugaring_kind().is_some() {
                 // Skip `async` desugaring `impl Future`.
                 continue;
             }
@@ -280,7 +281,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                     {
                     } else {
                         err.span_suggestion_verbose(
-                            fn_return.span.shrink_to_hi(),
+                            fn_return_span.shrink_to_hi(),
                             &format!(
                                 "{declare} `impl Trait` {captures}, {explicit}",
                                 declare = declare,
@@ -295,7 +296,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 TyKind::TraitObject(_, lt) => match lt.name {
                     LifetimeName::ImplicitObjectLifetimeDefault => {
                         err.span_suggestion_verbose(
-                            fn_return.span.shrink_to_hi(),
+                            fn_return_span.shrink_to_hi(),
                             &format!(
                                 "{declare} trait object {captures}, {explicit}",
                                 declare = declare,