Retain assembly operands span when lowering AST to HIR

tmiasko · tmiasko · commit 91fe54882543 · 2020-12-06T20:48:08.000+01:00
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1307,7 +1307,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         hir::InlineAsmOperand::Sym { expr: self.lower_expr_mut(expr) }
                     }
                 };
-                Some(op)
+                Some((op, *op_sp))
             })
             .collect();
 
@@ -1326,7 +1326,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             } = *p
             {
                 let op_sp = asm.operands[operand_idx].1;
-                match &operands[operand_idx] {
+                match &operands[operand_idx].0 {
                     hir::InlineAsmOperand::In { reg, .. }
                     | hir::InlineAsmOperand::Out { reg, .. }
                     | hir::InlineAsmOperand::InOut { reg, .. }
@@ -1385,8 +1385,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let mut used_input_regs = FxHashMap::default();
         let mut used_output_regs = FxHashMap::default();
         let mut required_features: Vec<&str> = vec![];
-        for (idx, op) in operands.iter().enumerate() {
-            let op_sp = asm.operands[idx].1;
+        for (idx, &(ref op, op_sp)) in operands.iter().enumerate() {
             if let Some(reg) = op.reg() {
                 // Make sure we don't accidentally carry features from the
                 // previous iteration.
@@ -1458,8 +1457,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                     skip = true;
 
                                     let idx2 = *o.get();
-                                    let op2 = &operands[idx2];
-                                    let op_sp2 = asm.operands[idx2].1;
+                                    let &(ref op2, op_sp2) = &operands[idx2];
                                     let reg2 = match op2.reg() {
                                         Some(asm::InlineAsmRegOrRegClass::Reg(r)) => r,
                                         _ => unreachable!(),
diff --git a/compiler/rustc_hir/src/arena.rs b/compiler/rustc_hir/src/arena.rs
@@ -14,7 +14,7 @@ macro_rules! arena_types {
             // HIR types
             [few] hir_krate: rustc_hir::Crate<$tcx>,
             [] arm: rustc_hir::Arm<$tcx>,
-            [] asm_operand: rustc_hir::InlineAsmOperand<$tcx>,
+            [] asm_operand: (rustc_hir::InlineAsmOperand<$tcx>, Span),
             [] asm_template: rustc_ast::InlineAsmTemplatePiece,
             [] attribute: rustc_ast::Attribute,
             [] block: rustc_hir::Block<$tcx>,
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -2143,7 +2143,7 @@ impl<'hir> InlineAsmOperand<'hir> {
 #[derive(Debug, HashStable_Generic)]
 pub struct InlineAsm<'hir> {
     pub template: &'hir [InlineAsmTemplatePiece],
-    pub operands: &'hir [InlineAsmOperand<'hir>],
+    pub operands: &'hir [(InlineAsmOperand<'hir>, Span)],
     pub options: InlineAsmOptions,
     pub line_spans: &'hir [Span],
 }
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -1191,7 +1191,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
             walk_list!(visitor, visit_expr, optional_expression);
         }
         ExprKind::InlineAsm(ref asm) => {
-            for op in asm.operands {
+            for (op, _op_sp) in asm.operands {
                 match op {
                     InlineAsmOperand::In { expr, .. }
                     | InlineAsmOperand::InOut { expr, .. }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1462,7 +1462,7 @@ impl<'a> State<'a> {
 
                 let mut args = vec![];
                 args.push(AsmArg::Template(ast::InlineAsmTemplatePiece::to_string(&a.template)));
-                args.extend(a.operands.iter().map(|o| AsmArg::Operand(o)));
+                args.extend(a.operands.iter().map(|(o, _)| AsmArg::Operand(o)));
                 if !a.options.is_empty() {
                     args.push(AsmArg::Options(a.options));
                 }
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -408,7 +408,7 @@ fn make_mirror_unadjusted<'a, 'tcx>(
             operands: asm
                 .operands
                 .iter()
-                .map(|op| {
+                .map(|(op, _op_sp)| {
                     match *op {
                         hir::InlineAsmOperand::In { reg, ref expr } => {
                             InlineAsmOperand::In { reg, expr: expr.to_ref() }
diff --git a/compiler/rustc_passes/src/intrinsicck.rs b/compiler/rustc_passes/src/intrinsicck.rs
@@ -347,7 +347,7 @@ impl ExprVisitor<'tcx> {
     }
 
     fn check_asm(&self, asm: &hir::InlineAsm<'tcx>) {
-        for (idx, op) in asm.operands.iter().enumerate() {
+        for (idx, (op, _op_sp)) in asm.operands.iter().enumerate() {
             match *op {
                 hir::InlineAsmOperand::In { reg, ref expr } => {
                     self.check_asm_operand_type(idx, reg, expr, asm.template, None);
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
@@ -1174,7 +1174,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                 };
 
                 // Do a first pass for writing outputs only
-                for op in asm.operands.iter().rev() {
+                for (op, _op_sp) in asm.operands.iter().rev() {
                     match op {
                         hir::InlineAsmOperand::In { .. }
                         | hir::InlineAsmOperand::Const { .. }
@@ -1197,7 +1197,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
                 // Then do a second pass for inputs
                 let mut succ = succ;
-                for op in asm.operands.iter().rev() {
+                for (op, _op_sp) in asm.operands.iter().rev() {
                     match op {
                         hir::InlineAsmOperand::In { expr, .. }
                         | hir::InlineAsmOperand::Const { expr, .. }
@@ -1454,7 +1454,7 @@ fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr<'tcx>) {
         }
 
         hir::ExprKind::InlineAsm(ref asm) => {
-            for op in asm.operands {
+            for (op, _op_sp) in asm.operands {
                 match op {
                     hir::InlineAsmOperand::Out { expr, .. } => {
                         if let Some(expr) = expr {
diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
@@ -1929,7 +1929,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     fn check_expr_asm(&self, asm: &'tcx hir::InlineAsm<'tcx>) -> Ty<'tcx> {
-        for op in asm.operands {
+        for (op, _op_sp) in asm.operands {
             match op {
                 hir::InlineAsmOperand::In { expr, .. } | hir::InlineAsmOperand::Const { expr } => {
                     self.check_expr_asm_operand(expr, true);
diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs
@@ -243,7 +243,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
             }
 
             hir::ExprKind::InlineAsm(ref asm) => {
-                for op in asm.operands {
+                for (op, _op_sp) in asm.operands {
                     match op {
                         hir::InlineAsmOperand::In { expr, .. }
                         | hir::InlineAsmOperand::Const { expr, .. }
diff --git a/src/tools/clippy/clippy_lints/src/loops.rs b/src/tools/clippy/clippy_lints/src/loops.rs
@@ -768,7 +768,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         ExprKind::InlineAsm(ref asm) => asm
             .operands
             .iter()
-            .map(|o| match o {
+            .map(|(o, _)| match o {
                 InlineAsmOperand::In { expr, .. }
                 | InlineAsmOperand::InOut { expr, .. }
                 | InlineAsmOperand::Const { expr }
diff --git a/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs b/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs
@@ -517,7 +517,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     }
                 }
                 asm.options.hash(&mut self.s);
-                for op in asm.operands {
+                for (op, _op_sp) in asm.operands {
                     match op {
                         InlineAsmOperand::In { reg, expr } => {
                             reg.hash(&mut self.s);
diff --git a/src/tools/clippy/clippy_lints/src/utils/inspector.rs b/src/tools/clippy/clippy_lints/src/utils/inspector.rs
@@ -293,7 +293,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
             println!("{}options: {:?}", ind, asm.options);
             println!("{}operands:", ind);
-            for op in asm.operands {
+            for (op, _op_sp) in asm.operands {
                 match op {
                     hir::InlineAsmOperand::In { expr, .. }
                     | hir::InlineAsmOperand::InOut { expr, .. }

Original file line number	Diff line number	Diff line change
`@@ -2143,7 +2143,7 @@ impl<'hir> InlineAsmOperand<'hir> {`
`2143`	`2143`	`#[derive(Debug, HashStable_Generic)]`
`2144`	`2144`	`pub struct InlineAsm<'hir> {`
`2145`	`2145`	`pub template: &'hir [InlineAsmTemplatePiece],`
`2146`		`- pub operands: &'hir [InlineAsmOperand<'hir>],`
	`2146`	`+ pub operands: &'hir [(InlineAsmOperand<'hir>, Span)],`
`2147`	`2147`	`pub options: InlineAsmOptions,`
`2148`	`2148`	`pub line_spans: &'hir [Span],`
`2149`	`2149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1191,7 +1191,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)`
`1191`	`1191`	`walk_list!(visitor, visit_expr, optional_expression);`
`1192`	`1192`	`}`
`1193`	`1193`	`ExprKind::InlineAsm(ref asm) => {`
`1194`		`- for op in asm.operands {`
	`1194`	`+ for (op, _op_sp) in asm.operands {`
`1195`	`1195`	`match op {`
`1196`	`1196`	`InlineAsmOperand::In { expr, .. }`
`1197`	`1197`	`\| InlineAsmOperand::InOut { expr, .. }`
Original file line number	Diff line number	Diff line change
`@@ -1462,7 +1462,7 @@ impl<'a> State<'a> {`
`1462`	`1462`
`1463`	`1463`	`let mut args = vec![];`
`1464`	`1464`	`args.push(AsmArg::Template(ast::InlineAsmTemplatePiece::to_string(&a.template)));`
`1465`		`- args.extend(a.operands.iter().map(\|o\| AsmArg::Operand(o)));`
	`1465`	`+ args.extend(a.operands.iter().map(\|(o, _)\| AsmArg::Operand(o)));`
`1466`	`1466`	`if !a.options.is_empty() {`
`1467`	`1467`	`args.push(AsmArg::Options(a.options));`
`1468`	`1468`	`}`
Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,7 @@ impl ExprVisitor<'tcx> {`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`fn check_asm(&self, asm: &hir::InlineAsm<'tcx>) {`
`350`		`- for (idx, op) in asm.operands.iter().enumerate() {`
	`350`	`+ for (idx, (op, _op_sp)) in asm.operands.iter().enumerate() {`
`351`	`351`	`match *op {`
`352`	`352`	`hir::InlineAsmOperand::In { reg, ref expr } => {`
`353`	`353`	`self.check_asm_operand_type(idx, reg, expr, asm.template, None);`
Original file line number	Diff line number	Diff line change
`@@ -1929,7 +1929,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1929`	`1929`	`}`
`1930`	`1930`
`1931`	`1931`	`fn check_expr_asm(&self, asm: &'tcx hir::InlineAsm<'tcx>) -> Ty<'tcx> {`
`1932`		`- for op in asm.operands {`
	`1932`	`+ for (op, _op_sp) in asm.operands {`
`1933`	`1933`	`match op {`
`1934`	`1934`	`hir::InlineAsmOperand::In { expr, .. } \| hir::InlineAsmOperand::Const { expr } => {`
`1935`	`1935`	`self.check_expr_asm_operand(expr, true);`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`hir::ExprKind::InlineAsm(ref asm) => {`
`246`		`- for op in asm.operands {`
	`246`	`+ for (op, _op_sp) in asm.operands {`
`247`	`247`	`match op {`
`248`	`248`	`hir::InlineAsmOperand::In { expr, .. }`
`249`	`249`	`\| hir::InlineAsmOperand::Const { expr, .. }`
Original file line number	Diff line number	Diff line change
`@@ -517,7 +517,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {`
`517`	`517`	`}`
`518`	`518`	`}`
`519`	`519`	`asm.options.hash(&mut self.s);`
`520`		`- for op in asm.operands {`
	`520`	`+ for (op, _op_sp) in asm.operands {`
`521`	`521`	`match op {`
`522`	`522`	`InlineAsmOperand::In { reg, expr } => {`
`523`	`523`	`reg.hash(&mut self.s);`