Remove Spans from HIR

compiler/rustc_ast_lowering/src/expr.rs

@@ -252,10 +252,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::Err => hir::ExprKind::Err,
                 ExprKind::Try(ref sub_expr) => self.lower_expr_try(e.span, sub_expr),
                 ExprKind::Paren(ref ex) => {
-                    let mut ex = self.lower_expr_mut(ex);
+                    let ex = self.lower_expr_mut(ex);
                     // Include parens in span, but only if it is a super-span.
-                    if e.span.contains(ex.span) {
-                        ex.span = e.span;
+                    let ex_span = &mut self.spans[ex.hir_id];
+                    if e.span.contains(*ex_span) {
+                        *ex_span = e.span;
                     }
                     // Merge attributes into the inner expression.
                     if !e.attrs.is_empty() {
@@ -281,9 +282,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span),
             };
 
-            let hir_id = self.lower_node_id(e.id);
+            let hir_id = self.lower_node_id(e.id, e.span);
             self.lower_attrs(hir_id, &e.attrs);
-            hir::Expr { hir_id, kind, span: e.span }
+            hir::Expr { hir_id, kind }
         })
     }
 
@@ -534,8 +535,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 // Lower condition:
                 let cond = self.with_loop_condition_scope(|this| this.lower_expr(cond));
-                let span_block =
-                    self.mark_span_with_reason(DesugaringKind::CondTemporary, cond.span, None);
+                let span_block = self.mark_span_with_reason(
+                    DesugaringKind::CondTemporary,
+                    self.spans[cond.hir_id],
+                    None,
+                );
                 // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
                 // to preserve drop semantics since `while cond { ... }` does not
                 // let temporaries live outside of `cond`.
@@ -573,7 +577,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 (
                     this.mark_span_with_reason(
                         DesugaringKind::TryBlock,
-                        expr.span,
+                        this.spans[expr.hir_id],
                         this.allow_try_trait.clone(),
                     ),
                     expr,
@@ -588,8 +592,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 (try_span, this.expr_unit(try_span))
             };
 
-            let ok_wrapped_span =
-                this.mark_span_with_reason(DesugaringKind::TryBlock, tail_expr.span, None);
+            let ok_wrapped_span = this.mark_span_with_reason(
+                DesugaringKind::TryBlock,
+                this.spans[tail_expr.hir_id],
+                None,
+            );
 
             // `::std::ops::Try::from_ok($tail_expr)`
             block.expr = Some(this.wrap_in_try_constructor(
@@ -624,9 +631,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::Guard::If(self.lower_expr(cond))
             }
         });
-        let hir_id = self.next_id();
+        let hir_id = self.next_id(arm.span);
         self.lower_attrs(hir_id, &arm.attrs);
-        hir::Arm { hir_id, pat, guard, body: self.lower_expr(&arm.body), span: arm.span }
+        hir::Arm { hir_id, pat, guard, body: self.lower_expr(&arm.body) }
     }
 
     /// Lower an `async` construct to a generator that is then wrapped so it implements `Future`.
@@ -654,7 +661,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(), 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 {
@@ -670,7 +677,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             Ident::with_dummy_span(sym::_task_context),
             hir::BindingAnnotation::Mutable,
         );
-        let param = hir::Param { hir_id: self.next_id(), pat, ty_span: span, span };
+        let param = hir::Param { hir_id: self.next_id(span), pat, ty_span: span };
         let params = arena_vec![self; param];
 
         let body_id = self.lower_body(move |this| {
@@ -692,7 +699,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             Some(hir::Movability::Static),
         );
         let generator =
-            hir::Expr { hir_id: self.lower_node_id(closure_node_id), kind: generator_kind, span };
+            hir::Expr { hir_id: self.lower_node_id(closure_node_id, span), kind: generator_kind };
 
         // `future::from_generator`:
         let unstable_span =
@@ -785,7 +792,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         // `::std::task::Poll::Ready(result) => break result`
         let loop_node_id = self.resolver.next_node_id();
-        let loop_hir_id = self.lower_node_id(loop_node_id);
+        let loop_hir_id = self.lower_node_id(loop_node_id, span);
         let ready_arm = {
             let x_ident = Ident::with_dummy_span(sym::result);
             let (x_pat, x_pat_hid) = self.pat_ident(span, x_ident);
@@ -845,7 +852,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let loop_expr = self.arena.alloc(hir::Expr {
             hir_id: loop_hir_id,
             kind: hir::ExprKind::Loop(loop_block, None, hir::LoopSource::Loop, span),
-            span,
         });
 
         // mut pinned => loop { ... }
@@ -1114,11 +1120,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let field_pats = self.arena.alloc_from_iter(fields.iter().map(|f| {
                     let pat = self.destructure_assign(&f.expr, eq_sign_span, assignments);
                     hir::FieldPat {
-                        hir_id: self.next_id(),
+                        hir_id: self.next_id(f.span),
                         ident: f.ident,
                         pat,
                         is_shorthand: f.is_shorthand,
-                        span: f.span,
                     }
                 }));
                 let qpath = self.lower_qpath(
@@ -1255,7 +1260,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let target_id = match destination {
             Some((id, _)) => {
                 if let Some(loop_id) = self.resolver.get_label_res(id) {
-                    Ok(self.lower_node_id(loop_id))
+                    Ok(self.lower_node_id(loop_id, DUMMY_SP))
                 } else {
                     Err(hir::LoopIdError::UnresolvedLabel)
                 }
@@ -1264,7 +1269,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .loop_scopes
                 .last()
                 .cloned()
-                .map(|id| Ok(self.lower_node_id(id)))
+                .map(|id| Ok(self.lower_node_id(id, DUMMY_SP)))
                 .unwrap_or(Err(hir::LoopIdError::OutsideLoopScope)),
         };
         hir::Destination { label: destination.map(|(_, label)| label), target_id }
@@ -1660,10 +1665,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_field(&mut self, f: &Field) -> hir::Field<'hir> {
         hir::Field {
-            hir_id: self.next_id(),
+            hir_id: self.next_id(f.span),
             ident: f.ident,
             expr: self.lower_expr(&f.expr),
-            span: f.span,
             is_shorthand: f.is_shorthand,
         }
     }
@@ -1718,13 +1722,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::Expr<'hir> {
         let orig_head_span = head.span;
         // expand <head>
-        let mut head = self.lower_expr_mut(head);
+        let head = self.lower_expr_mut(head);
         let desugared_span = self.mark_span_with_reason(
             DesugaringKind::ForLoop(ForLoopLoc::Head),
             orig_head_span,
             None,
         );
-        head.span = desugared_span;
+        self.spans[head.hir_id] = desugared_span;
 
         let iter = Ident::with_dummy_span(sym::iter);
 
@@ -1816,7 +1820,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             e.span.with_hi(orig_head_span.hi()),
         );
         let loop_expr =
-            self.arena.alloc(hir::Expr { hir_id: self.lower_node_id(e.id), kind, span: e.span });
+            self.arena.alloc(hir::Expr { hir_id: self.lower_node_id(e.id, e.span), kind });
 
         // `mut iter => { ... }`
         let iter_arm = self.arm(iter_pat, loop_expr);
@@ -1939,7 +1943,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let thin_attrs = ThinVec::from(attrs);
             let catch_scope = self.catch_scopes.last().copied();
             let ret_expr = if let Some(catch_node) = catch_scope {
-                let target_id = Ok(self.lower_node_id(catch_node));
+                let target_id = Ok(self.lower_node_id(catch_node, DUMMY_SP));
                 self.arena.alloc(self.expr(
                     try_span,
                     hir::ExprKind::Break(
@@ -2112,8 +2116,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn expr_unsafe(&mut self, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
-        let hir_id = self.next_id();
-        let span = expr.span;
+        let span = self.spans[expr.hir_id];
+        let hir_id = self.next_id(span);
         self.expr(
             span,
             hir::ExprKind::Block(
@@ -2122,7 +2126,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     expr: Some(expr),
                     hir_id,
                     rules: hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::CompilerGenerated),
-                    span,
                     targeted_by_break: false,
                 }),
                 None,
@@ -2142,7 +2145,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         b: &'hir hir::Block<'hir>,
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
-        self.expr(b.span, hir::ExprKind::Block(b, None), attrs)
+        let span = self.spans[b.hir_id];
+        self.expr(span, hir::ExprKind::Block(b, None), attrs)
     }
 
     pub(super) fn expr(
@@ -2151,16 +2155,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
         kind: hir::ExprKind<'hir>,
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
-        let hir_id = self.next_id();
+        let hir_id = self.next_id(span);
         self.lower_attrs(hir_id, &attrs);
-        hir::Expr { hir_id, kind, span }
+        hir::Expr { hir_id, kind }
     }
 
     fn field(&mut self, ident: Ident, expr: &'hir hir::Expr<'hir>, span: Span) -> hir::Field<'hir> {
-        hir::Field { hir_id: self.next_id(), ident, span, expr, is_shorthand: false }
+        hir::Field { hir_id: self.next_id(span), ident, expr, is_shorthand: false }
     }
 
     fn arm(&mut self, pat: &'hir hir::Pat<'hir>, expr: &'hir hir::Expr<'hir>) -> hir::Arm<'hir> {
-        hir::Arm { hir_id: self.next_id(), pat, guard: None, span: expr.span, body: expr }
+        let span = self.spans[expr.hir_id];
+        hir::Arm { hir_id: self.next_id(span), pat, guard: None, body: expr }
     }
 }