Remove span from hir::Pat.

Author: cjgillot

compiler/rustc_ast_lowering/src/item.rs

@@ -1129,7 +1129,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             // parameters (c.f. rust-lang/rust#64512).
             for (index, parameter) in decl.inputs.iter().enumerate() {
                 let parameter = this.lower_param(parameter);
-                let span = parameter.pat.span;
+                let span = this.spans[parameter.pat.hir_id];
 
                 // Check if this is a binding pattern, if so, we can optimize and avoid adding a
                 // `let <pat> = __argN;` statement. In this case, we do not rename the parameter.

compiler/rustc_ast_lowering/src/lib.rs

@@ -2656,7 +2656,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.arena.alloc(hir::Pat {
                 hir_id,
                 kind: hir::PatKind::Binding(bm, hir_id, ident.with_span_pos(span), None),
-                span,
                 default_binding_modes: true,
             }),
             hir_id,
@@ -2668,19 +2667,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn pat(&mut self, span: Span, kind: hir::PatKind<'hir>) -> &'hir hir::Pat<'hir> {
-        self.arena.alloc(hir::Pat {
-            hir_id: self.next_id(span),
-            kind,
-            span,
-            default_binding_modes: true,
-        })
+        self.arena.alloc(hir::Pat { hir_id: self.next_id(span), kind, default_binding_modes: true })
     }
 
     fn pat_without_dbm(&mut self, span: Span, kind: hir::PatKind<'hir>) -> &'hir hir::Pat<'hir> {
         self.arena.alloc(hir::Pat {
             hir_id: self.next_id(span),
             kind,
-            span,
             default_binding_modes: false,
         })
     }

compiler/rustc_ast_lowering/src/pat.rs

@@ -275,7 +275,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.arena.alloc(hir::Pat {
             hir_id: self.lower_node_id(p.id, p.span),
             kind,
-            span: p.span,
             default_binding_modes: true,
         })
     }

compiler/rustc_hir/src/hir.rs

@@ -798,7 +798,6 @@ pub struct Pat<'hir> {
     #[stable_hasher(ignore)]
     pub hir_id: HirId,
     pub kind: PatKind<'hir>,
-    pub span: Span,
     // Whether to use default binding modes.
     // At present, this is false only for destructuring assignment.
     pub default_binding_modes: bool,
@@ -3056,7 +3055,7 @@ impl<'hir> Node<'hir> {
 mod size_asserts {
     rustc_data_structures::static_assert_size!(super::Block<'static>, 40);
     rustc_data_structures::static_assert_size!(super::Expr<'static>, 64);
-    rustc_data_structures::static_assert_size!(super::Pat<'static>, 88);
+    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);
 

compiler/rustc_hir/src/pat_util.rs

@@ -2,7 +2,6 @@ use crate::def::{CtorOf, DefKind, Res};
 use crate::def_id::DefId;
 use crate::hir::{self, HirId, PatKind};
 use rustc_span::symbol::Ident;
-use rustc_span::Span;
 
 use std::iter::{Enumerate, ExactSizeIterator};
 
@@ -60,10 +59,10 @@ impl<T: ExactSizeIterator> EnumerateAndAdjustIterator for T {
 impl hir::Pat<'_> {
     /// Call `f` on every "binding" in a pattern, e.g., on `a` in
     /// `match foo() { Some(a) => (), None => () }`
-    pub fn each_binding(&self, mut f: impl FnMut(hir::BindingAnnotation, HirId, Span, Ident)) {
+    pub fn each_binding(&self, mut f: impl FnMut(hir::BindingAnnotation, HirId, Ident)) {
         self.walk_always(|p| {
             if let PatKind::Binding(binding_mode, _, ident, _) = p.kind {
-                f(binding_mode, p.hir_id, p.span, ident);
+                f(binding_mode, p.hir_id, ident);
             }
         });
     }
@@ -72,17 +71,14 @@ impl hir::Pat<'_> {
     /// `match foo() { Some(a) => (), None => () }`.
     ///
     /// When encountering an or-pattern `p_0 | ... | p_n` only `p_0` will be visited.
-    pub fn each_binding_or_first(
-        &self,
-        f: &mut impl FnMut(hir::BindingAnnotation, HirId, Span, Ident),
-    ) {
+    pub fn each_binding_or_first(&self, f: &mut impl FnMut(hir::BindingAnnotation, HirId, Ident)) {
         self.walk(|p| match &p.kind {
             PatKind::Or(ps) => {
                 ps[0].each_binding_or_first(f);
                 false
             }
             PatKind::Binding(bm, _, ident, _) => {
-                f(*bm, p.hir_id, p.span, *ident);
+                f(*bm, p.hir_id, *ident);
                 true
             }
             _ => true,
@@ -150,7 +146,7 @@ impl hir::Pat<'_> {
     // ref bindings are be implicit after #42640 (default match binding modes). See issue #44848.
     pub fn contains_explicit_ref_binding(&self) -> Option<hir::Mutability> {
         let mut result = None;
-        self.each_binding(|annotation, _, _, _| match annotation {
+        self.each_binding(|annotation, _, _| match annotation {
             hir::BindingAnnotation::Ref => match result {
                 None | Some(hir::Mutability::Not) => result = Some(hir::Mutability::Not),
                 _ => {}

compiler/rustc_hir_pretty/src/lib.rs

@@ -341,26 +341,29 @@ impl<'a> State<'a> {
     pub fn commasep_cmnt<T, F, G>(&mut self, b: Breaks, elts: &[T], mut op: F, mut get_span: G)
     where
         F: FnMut(&mut State<'_>, &T),
-        G: FnMut(&T) -> rustc_span::Span,
+        G: FnMut(&State<'_>, &T) -> rustc_span::Span,
     {
         self.rbox(0, b);
         let len = elts.len();
         let mut i = 0;
         for elt in elts {
-            self.maybe_print_comment(get_span(elt).hi());
+            self.maybe_print_comment(get_span(self, elt).hi());
             op(self, elt);
             i += 1;
             if i < len {
                 self.s.word(",");
-                self.maybe_print_trailing_comment(get_span(elt), Some(get_span(&elts[i]).hi()));
+                self.maybe_print_trailing_comment(
+                    get_span(self, elt),
+                    Some(get_span(self, &elts[i]).hi()),
+                );
                 self.space_if_not_bol();
             }
         }
         self.end();
     }
 
     pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[hir::Expr<'_>]) {
-        self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&e), |e| e.span)
+        self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&e), |_, e| e.span)
     }
 
     pub fn print_mod(&mut self, _mod: &hir::Mod<'_>, attrs: &[ast::Attribute]) {
@@ -1237,7 +1240,7 @@ impl<'a> State<'a> {
                 s.print_expr(&field.expr);
                 s.end()
             },
-            |f| f.span,
+            |_, f| f.span,
         );
         match *wth {
             Some(ref expr) => {
@@ -1887,7 +1890,8 @@ impl<'a> State<'a> {
     }
 
     pub fn print_pat(&mut self, pat: &hir::Pat<'_>) {
-        self.maybe_print_comment(pat.span.lo());
+        let span = self.span(pat.hir_id);
+        self.maybe_print_comment(span.lo());
         self.ann.pre(self, AnnNode::Pat(pat));
         // Pat isn't normalized, but the beauty of it
         // is that it doesn't matter
@@ -1951,7 +1955,7 @@ impl<'a> State<'a> {
                         s.print_pat(&f.pat);
                         s.end()
                     },
-                    |f| f.pat.span,
+                    |s, f| s.span(f.pat.hir_id),
                 );
                 if etc {
                     if !fields.is_empty() {

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

@@ -464,7 +464,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             local_visitor.visit_expr(expr);
         }
         let err_span = if let Some(pattern) = local_visitor.found_arg_pattern {
-            pattern.span
+            self.tcx.hir().span(pattern.hir_id)
         } else if let Some(span) = arg_data.span {
             // `span` here lets us point at `sum` instead of the entire right hand side expr:
             // error[E0282]: type annotations needed
@@ -637,12 +637,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             //            with the type parameter `_` specified
             // ```
             err.span_label(
-                pattern.span,
+                self.tcx.hir().span(pattern.hir_id),
                 format!("consider giving this closure parameter {}", suffix),
             );
         } else if let Some(pattern) = local_visitor.found_local_pattern {
+            let pattern_span = self.tcx.hir().span(pattern.hir_id);
             let msg = if let Some(simple_ident) = pattern.simple_ident() {
-                match pattern.span.desugaring_kind() {
+                match pattern_span.desugaring_kind() {
                     None => format!("consider giving `{}` {}", simple_ident, suffix),
                     Some(DesugaringKind::ForLoop(_)) => {
                         "the element type for this iterator is not specified".to_string()
@@ -652,7 +653,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             } else {
                 format!("consider giving this pattern {}", suffix)
             };
-            err.span_label(pattern.span, msg);
+            err.span_label(pattern_span, msg);
         } else if let Some(e) = local_visitor.found_method_call {
             if let ExprKind::MethodCall(segment, _, exprs, _) = &e.kind {
                 // Suggest impl candidates:

compiler/rustc_mir_build/src/build/mod.rs

@@ -858,10 +858,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         argument_scope: region::Scope,
         expr: &Expr<'_, 'tcx>,
     ) -> BlockAnd<()> {
+        let tcx = self.tcx;
+        let tcx_hir = tcx.hir();
+        let hir_typeck_results = self.typeck_results;
+
         // Allocate locals for the function arguments
         for &ArgInfo(ty, _, arg_opt, _) in arguments.iter() {
-            let source_info =
-                SourceInfo::outermost(arg_opt.map_or(self.fn_span, |arg| arg.pat.span));
+            let source_info = SourceInfo::outermost(
+                arg_opt.map_or(self.fn_span, |arg| tcx_hir.span(arg.pat.hir_id)),
+            );
             let arg_local = self.local_decls.push(LocalDecl::with_source_info(ty, source_info));
 
             // If this is a simple binding pattern, give debuginfo a nice name.
@@ -876,10 +881,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
         }
 
-        let tcx = self.tcx;
-        let tcx_hir = tcx.hir();
-        let hir_typeck_results = self.typeck_results;
-
         // In analyze_closure() in upvar.rs we gathered a list of upvars used by a
         // indexed closure and we stored in a map called closure_captures in TypeckResults
         // with the closure's DefId. Here, we run through that vec of UpvarIds for
@@ -954,7 +955,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             // Make sure we drop (parts of) the argument even when not matched on.
             self.schedule_drop(
-                arg_opt.as_ref().map_or(expr.span, |arg| arg.pat.span),
+                arg_opt.as_ref().map_or(expr.span, |arg| tcx_hir.span(arg.pat.hir_id)),
                 argument_scope,
                 local,
                 DropKind::Value,