Remove span from hir::Local.

cjgillot · cjgillot · commit afc6e69639ed · 2021-01-06T21:41:10.000+01:00
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1776,7 +1776,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 ty,
                 pat: self.lower_pat(&l.pat),
                 init,
-                span: l.span,
                 attrs: l.attrs.iter().map(|a| self.lower_attr(a)).collect::<Vec<_>>().into(),
                 source: hir::LocalSource::Normal,
             },
@@ -2495,8 +2494,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         pat: &'hir hir::Pat<'hir>,
         source: hir::LocalSource,
     ) -> hir::Stmt<'hir> {
-        let local =
-            hir::Local { attrs, hir_id: self.next_id(span), init, pat, source, span, ty: None };
+        let local = hir::Local { attrs, hir_id: self.next_id(span), init, pat, source, ty: None };
         self.stmt(span, hir::StmtKind::Local(self.arena.alloc(local)))
     }
 
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -1135,7 +1135,6 @@ pub struct Local<'hir> {
     /// Initializer expression to set the value, if any.
     pub init: Option<&'hir Expr<'hir>>,
     pub hir_id: HirId,
-    pub span: Span,
     pub attrs: AttrVec,
     /// Can be `ForLoopDesugar` if the `let` statement is part of a `for` loop
     /// desugaring. Otherwise will be `Normal`.
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -65,7 +65,7 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
         intravisit::walk_local(self, loc);
 
         let (msg, sp) = match loc.source {
-            hir::LocalSource::Normal => ("local binding", Some(loc.span)),
+            hir::LocalSource::Normal => ("local binding", Some(self.tcx.hir().span(loc.hir_id))),
             hir::LocalSource::ForLoopDesugar => ("`for` loop binding", None),
             hir::LocalSource::AsyncFn => ("async fn binding", None),
             hir::LocalSource::AwaitDesugar => ("`await` future binding", None),
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
@@ -514,7 +514,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Type check a `let` statement.
     pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
         // Determine and write the type which we'll check the pattern against.
-        let ty = self.local_ty(local.span, local.hir_id).decl_ty;
+        let local_span = self.tcx().hir().span(local.hir_id);
+        let ty = self.local_ty(local_span, local.hir_id).decl_ty;
         self.write_ty(local.hir_id, ty);
 
         // Type check the initializer.
diff --git a/compiler/rustc_typeck/src/check/gather_locals.rs b/compiler/rustc_typeck/src/check/gather_locals.rs
@@ -80,7 +80,8 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
             }
             None => None,
         };
-        self.assign(local.span, local.hir_id, local_ty);
+        let local_span = self.fcx.tcx.hir().span(local.hir_id);
+        self.assign(local_span, local.hir_id, local_ty);
 
         debug!(
             "local variable {:?} is assigned type {}",
diff --git a/compiler/rustc_typeck/src/check/writeback.rs b/compiler/rustc_typeck/src/check/writeback.rs
@@ -319,8 +319,9 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
 
     fn visit_local(&mut self, l: &'tcx hir::Local<'tcx>) {
         intravisit::walk_local(self, l);
-        let var_ty = self.fcx.local_ty(l.span, l.hir_id).decl_ty;
-        let var_ty = self.resolve(var_ty, &l.span);
+        let span = self.tcx().hir().span(l.hir_id);
+        let var_ty = self.fcx.local_ty(span, l.hir_id).decl_ty;
+        let var_ty = self.resolve(var_ty, &span);
         self.write_ty_to_typeck_results(l.hir_id, var_ty);
     }
 
diff --git a/src/tools/clippy/clippy_lints/src/default.rs b/src/tools/clippy/clippy_lints/src/default.rs
@@ -205,12 +205,13 @@ impl LateLintPass<'_> for Default {
 
                 // span lint once per statement that binds default
                 let first_assign_span = cx.tcx.hir().span(first_assign.unwrap().hir_id);
+                let local_span = cx.tcx.hir().span(local.hir_id);
                 span_lint_and_note(
                     cx,
                     FIELD_REASSIGN_WITH_DEFAULT,
                     first_assign_span,
                     "field assignment outside of initializer for an instance created with Default::default()",
-                    Some(local.span),
+                    Some(local_span),
                     &format!(
                         "consider initializing the variable with `{}` and removing relevant reassignments",
                         sugg
diff --git a/src/tools/clippy/clippy_lints/src/let_underscore.rs b/src/tools/clippy/clippy_lints/src/let_underscore.rs
@@ -109,7 +109,8 @@ const SYNC_GUARD_PATHS: [&[&str]; 3] = [
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
     fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
-        if in_external_macro(cx.tcx.sess, local.span) {
+        let local_span = cx.tcx.hir().span(local.hir_id);
+        if in_external_macro(cx.tcx.sess, local_span) {
             return;
         }
 
@@ -138,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     span_lint_and_help(
                         cx,
                         LET_UNDERSCORE_LOCK,
-                        local.span,
+                        local_span,
                         "non-binding let on a synchronization lock",
                         None,
                         "consider using an underscore-prefixed named \
@@ -148,7 +149,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     span_lint_and_help(
                         cx,
                         LET_UNDERSCORE_DROP,
-                        local.span,
+                        local_span,
                         "non-binding `let` on a type that implements `Drop`",
                         None,
                         "consider using an underscore-prefixed named \
@@ -158,7 +159,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     span_lint_and_help(
                         cx,
                         LET_UNDERSCORE_MUST_USE,
-                        local.span,
+                        local_span,
                         "non-binding let on an expression with `#[must_use]` type",
                         None,
                         "consider explicitly using expression value"
@@ -167,7 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     span_lint_and_help(
                         cx,
                         LET_UNDERSCORE_MUST_USE,
-                        local.span,
+                        local_span,
                         "non-binding let on a result of a `#[must_use]` function",
                         None,
                         "consider explicitly using function result"
diff --git a/src/tools/clippy/clippy_lints/src/map_unit_fn.rs b/src/tools/clippy/clippy_lints/src/map_unit_fn.rs
@@ -141,7 +141,7 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) ->
                     // If block only contains statements,
                     // reduce `{ X; }` to `X` or `X;`
                     match inner_stmt.kind {
-                        hir::StmtKind::Local(ref local) => Some(local.span),
+                        hir::StmtKind::Local(ref local) => Some(cx.tcx.hir().span(local.hir_id)),
                         hir::StmtKind::Expr(ref e) => Some(e.span),
                         hir::StmtKind::Semi(..) => Some(cx.tcx.hir().span(inner_stmt.hir_id)),
                         hir::StmtKind::Item(..) => None,
diff --git a/src/tools/clippy/clippy_lints/src/matches.rs b/src/tools/clippy/clippy_lints/src/matches.rs
@@ -607,9 +607,10 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     }
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
+        let local_span = cx.tcx.hir().span(local.hir_id);
         if_chain! {
-            if !in_external_macro(cx.sess(), local.span);
-            if !in_macro(local.span);
+            if !in_external_macro(cx.sess(), local_span);
+            if !in_macro(local_span);
             if let Some(ref expr) = local.init;
             if let ExprKind::Match(ref target, ref arms, MatchSource::Normal) = expr.kind;
             if arms.len() == 1 && arms[0].guard.is_none();
@@ -626,7 +627,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 span_lint_and_sugg(
                     cx,
                     INFALLIBLE_DESTRUCTURING_MATCH,
-                    local.span,
+                    local_span,
                     "you seem to be trying to use `match` to destructure a single infallible pattern. \
                     Consider using `let`",
                     "try this",
@@ -1245,7 +1246,7 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
     // a macro. See PR #6435
     if_chain! {
         if let Some(match_snippet) = snippet_opt(cx, expr.span);
-        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
+        if let Some(arm_snippet) = snippet_opt(cx, cx.tcx.hir().span(arms[0].hir_id));
         if let Some(ex_snippet) = snippet_opt(cx, ex.span);
         let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
         if rest_snippet.contains("=>");
@@ -1288,7 +1289,7 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
             // If this match is in a local (`let`) stmt
             let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
                 (
-                    parent_let_node.span,
+                    cx.tcx.hir().span(parent_let_node.hir_id),
                     format!(
                         "let {} = {};\n{}let {} = {};",
                         snippet_with_applicability(cx, bind_names, "..", &mut applicability),
diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs
@@ -310,7 +310,8 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                 if an == BindingAnnotation::Ref || an == BindingAnnotation::RefMut {
                     // use the macro callsite when the init span (but not the whole local span)
                     // comes from an expansion like `vec![1, 2, 3]` in `let ref _ = vec![1, 2, 3];`
-                    let sugg_init = if init.span.from_expansion() && !local.span.from_expansion() {
+                    let local_span = cx.tcx.hir().span(local.hir_id);
+                    let sugg_init = if init.span.from_expansion() && !local_span.from_expansion() {
                         Sugg::hir_with_macro_callsite(cx, init, "..")
                     } else {
                         Sugg::hir(cx, init, "..")
diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs
@@ -79,7 +79,8 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
         if let hir::PatKind::Wild = local.pat.kind {
             return;
         }
-        check_ty(cx, local.span, cx.typeck_results().pat_ty(&*local.pat));
+        let local_span = cx.tcx.hir().span(local.hir_id);
+        check_ty(cx, local_span, cx.typeck_results().pat_ty(&*local.pat));
     }
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/returns.rs b/src/tools/clippy/clippy_lints/src/returns.rs
@@ -89,16 +89,17 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             if !last_statement_borrows(cx, initexpr);
             if !in_external_macro(cx.sess(), initexpr.span);
             if !in_external_macro(cx.sess(), retexpr.span);
-            if !in_external_macro(cx.sess(), local.span);
-            if !in_macro(local.span);
+            let local_span = cx.tcx.hir().span(local.hir_id);
+            if !in_external_macro(cx.sess(), local_span);
+            if !in_macro(local_span);
             then {
                 span_lint_and_then(
                     cx,
                     LET_AND_RETURN,
                     retexpr.span,
                     "returning the result of a `let` binding from a block",
                     |err| {
-                        err.span_label(local.span, "unnecessary `let` binding");
+                        err.span_label(local_span, "unnecessary `let` binding");
 
                         if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
                             if !cx.typeck_results().expr_adjustments(&retexpr).is_empty() {
@@ -107,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                             err.multipart_suggestion(
                                 "return the expression directly",
                                 vec![
-                                    (local.span, String::new()),
+                                    (local_span, String::new()),
                                     (retexpr.span, snippet),
                                 ],
                                 Applicability::MachineApplicable,
diff --git a/src/tools/clippy/clippy_lints/src/shadow.rs b/src/tools/clippy/clippy_lints/src/shadow.rs
@@ -139,7 +139,8 @@ fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>, bindings: &
 }
 
 fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &mut Vec<(Symbol, Span)>) {
-    if in_external_macro(cx.sess(), local.span) {
+    let span = cx.tcx.hir().span(local.hir_id);
+    if in_external_macro(cx.sess(), span) {
         return;
     }
     if higher::is_from_for_desugar(local) {
@@ -149,7 +150,6 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
         ref pat,
         ref ty,
         ref init,
-        span,
         ..
     } = *local;
     if let Some(ref t) = *ty {

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,8 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {`
`80`	`80`	`}`
`81`	`81`	`None => None,`
`82`	`82`	`};`
`83`		`- self.assign(local.span, local.hir_id, local_ty);`
	`83`	`+ let local_span = self.fcx.tcx.hir().span(local.hir_id);`
	`84`	`+ self.assign(local_span, local.hir_id, local_ty);`
`84`	`85`
`85`	`86`	`debug!(`
`86`	`87`	`"local variable {:?} is assigned type {}",`