Use a struct instead of a tuple for inline asm output operands

diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index de540e5cfb388f1e793eb4e1756ef5d63ba82434..f17c865dc902bd8b9b5f3ee19096d834c8c71072 100644 (file)
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -368,8 +368,7 @@ fn expr(&mut self, expr: &hir::Expr, pred: CFGIndex) -> CFGIndex {
                 }), pred);
                 let post_outputs = self.exprs(outputs.map(|a| {
                     debug!("cfg::construct InlineAsm id:{} output:{:?}", expr.id, a);
-                    let &(_, ref expr, _, _) = a;
-                    &**expr
+                    &*a.expr
                 }), post_inputs);
                 self.add_ast_node(expr.id, &[post_outputs])
             }

diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
index 316b49e1de408116133f908f11c9a403e0d781eb..58f6972277703c44f22f74086c87836cb8062051 100644 (file)
--- a/src/librustc/middle/expr_use_visitor.rs
+++ b/src/librustc/middle/expr_use_visitor.rs
@@ -458,12 +458,12 @@ pub fn walk_expr(&mut self, expr: &hir::Expr) {
                     self.consume_expr(&**input);
                 }
 
-                for &(_, ref output, is_rw, is_indirect) in &ia.outputs {
-                    if is_indirect {
-                        self.consume_expr(&**output);
+                for output in &ia.outputs {
+                    if output.is_indirect {
+                        self.consume_expr(&*output.expr);
                     } else {
-                        self.mutate_expr(expr, &**output,
-                                           if is_rw { WriteAndRead } else { JustWrite });
+                        self.mutate_expr(expr, &*output.expr,
+                                         if output.is_rw { WriteAndRead } else { JustWrite });
                     }
                 }
             }

diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 9c8cc45d3962ff14e5f129af7d12fd3ae4ef100f..30061212a8526d5f2c7c626b3aec43f01dd37112 100644 (file)
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -1167,15 +1167,15 @@ fn propagate_through_expr(&mut self, expr: &Expr, succ: LiveNode)
           hir::ExprInlineAsm(ref ia) => {
 
             let succ = ia.outputs.iter().rev().fold(succ,
-                |succ, &(_, ref expr, is_rw, is_indirect)| {
+                |succ, out| {
                     // see comment on lvalues
                     // in propagate_through_lvalue_components()
-                    if is_indirect {
-                        self.propagate_through_expr(&**expr, succ)
+                    if out.is_indirect {
+                        self.propagate_through_expr(&*out.expr, succ)
                     } else {
-                        let acc = if is_rw { ACC_WRITE|ACC_READ } else { ACC_WRITE };
-                        let succ = self.write_lvalue(&**expr, succ, acc);
-                        self.propagate_through_lvalue_components(&**expr, succ)
+                        let acc = if out.is_rw { ACC_WRITE|ACC_READ } else { ACC_WRITE };
+                        let succ = self.write_lvalue(&*out.expr, succ, acc);
+                        self.propagate_through_lvalue_components(&*out.expr, succ)
                     }
                 }
             );
@@ -1423,11 +1423,11 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
         }
 
         // Output operands must be lvalues
-        for &(_, ref out, _, is_indirect) in &ia.outputs {
-          if !is_indirect {
-            this.check_lvalue(&**out);
+        for out in &ia.outputs {
+          if !out.is_indirect {
+            this.check_lvalue(&*out.expr);
           }
-          this.visit_expr(&**out);
+          this.visit_expr(&*out.expr);
         }
 
         intravisit::walk_expr(this, expr);

diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs
index c9a09989f04413dc7b7e5d21c152224ad8187ea8..aa73871d84e8f045567fd0f589300ea67aab64ea 100644 (file)
--- a/src/librustc_front/fold.rs
+++ b/src/librustc_front/fold.rs
@@ -1127,8 +1127,13 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span, attrs }: Expr, folder: &
                 expn_id,
             }) => ExprInlineAsm(InlineAsm {
                 inputs: inputs.move_map(|(c, input)| (c, folder.fold_expr(input))),
-                outputs: outputs.move_map(|(c, out, is_rw, is_indirect)| {
-                    (c, folder.fold_expr(out), is_rw, is_indirect)
+                outputs: outputs.move_map(|out| {
+                    InlineAsmOutput {
+                        constraint: out.constraint,
+                        expr: folder.fold_expr(out.expr),
+                        is_rw: out.is_rw,
+                        is_indirect: out.is_indirect,
+                    }
                 }),
                 asm: asm,
                 asm_str_style: asm_str_style,

diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs
index bc95599fb7a7042a0a9965348bbd7ddbcc2f751c..192209b8f7628fc44bb290b3329f67290972acf0 100644 (file)
--- a/src/librustc_front/hir.rs
+++ b/src/librustc_front/hir.rs
@@ -887,11 +887,19 @@ pub enum Ty_ {
     TyInfer,
 }
 
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub struct InlineAsmOutput {
+    pub constraint: InternedString,
+    pub expr: P<Expr>,
+    pub is_rw: bool,
+    pub is_indirect: bool,
+}
+
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct InlineAsm {
     pub asm: InternedString,
     pub asm_str_style: StrStyle,
-    pub outputs: Vec<(InternedString, P<Expr>, bool, bool)>,
+    pub outputs: Vec<InlineAsmOutput>,
     pub inputs: Vec<(InternedString, P<Expr>)>,
     pub clobbers: Vec<InternedString>,
     pub volatile: bool,

diff --git a/src/librustc_front/intravisit.rs b/src/librustc_front/intravisit.rs
index d0f2a9dca17fdc562b3a66e08b62b223b68aefb1..bf77301b03a778df0bb2fe6f6a84c1c5912885d5 100644 (file)
--- a/src/librustc_front/intravisit.rs
+++ b/src/librustc_front/intravisit.rs
@@ -803,8 +803,8 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             for &(_, ref input) in &ia.inputs {
                 visitor.visit_expr(&input)
             }
-            for &(_, ref output, _, _) in &ia.outputs {
-                visitor.visit_expr(&output)
+            for output in &ia.outputs {
+                visitor.visit_expr(&output.expr)
             }
         }
     }

diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
index e5ea737f621ade1bd5d9dfb6fd60104d7bba741b..2baee3f52837d1bf726c63ddd765ea6462033fbe 100644 (file)
--- a/src/librustc_front/lowering.rs
+++ b/src/librustc_front/lowering.rs
@@ -1202,8 +1202,13 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                               .map(|&(ref c, ref input)| (c.clone(), lower_expr(lctx, input)))
                               .collect(),
                 outputs: outputs.iter()
-                                .map(|&(ref c, ref out, is_rw, is_indirect)| {
-                                    (c.clone(), lower_expr(lctx, out), is_rw, is_indirect)
+                                .map(|out| {
+                                    hir::InlineAsmOutput {
+                                        constraint: out.constraint.clone(),
+                                        expr: lower_expr(lctx, &out.expr),
+                                        is_rw: out.is_rw,
+                                        is_indirect: out.is_indirect,
+                                    }
                                 })
                                 .collect(),
                 asm: asm.clone(),

diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs
index c87750002686c8445a5e3ab01dc1c26a13e127db..d4cd70df38a495c48fed16c30b69bb48364b55e8 100644 (file)
--- a/src/librustc_front/print/pprust.rs
+++ b/src/librustc_front/print/pprust.rs
@@ -1502,15 +1502,15 @@ pub fn print_expr(&mut self, expr: &hir::Expr) -> io::Result<()> {
                 try!(self.print_string(&a.asm, a.asm_str_style));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent, &a.outputs, |s, &(ref co, ref o, is_rw, _)| {
-                    match co.slice_shift_char() {
-                        Some(('=', operand)) if is_rw => {
+                try!(self.commasep(Inconsistent, &a.outputs, |s, out| {
+                    match out.constraint.slice_shift_char() {
+                        Some(('=', operand)) if out.is_rw => {
                             try!(s.print_string(&format!("+{}", operand), ast::CookedStr))
                         }
-                        _ => try!(s.print_string(&co, ast::CookedStr)),
+                        _ => try!(s.print_string(&out.constraint, ast::CookedStr)),
                     }
                     try!(s.popen());
-                    try!(s.print_expr(&**o));
+                    try!(s.print_expr(&*out.expr));
                     try!(s.pclose());
                     Ok(())
                 }));

diff --git a/src/librustc_trans/trans/asm.rs b/src/librustc_trans/trans/asm.rs
index efa34fbcbdcf87dbdbbbb30817e6d67635963aa8..ea0397c690c1d4396a831ddad617b5ba296e8210 100644 (file)
--- a/src/librustc_trans/trans/asm.rs
+++ b/src/librustc_trans/trans/asm.rs
@@ -41,27 +41,27 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm)
     // Prepare the output operands
     let mut outputs = Vec::new();
     let mut inputs = Vec::new();
-    for (i, &(ref c, ref out, is_rw, is_indirect)) in ia.outputs.iter().enumerate() {
-        constraints.push((*c).clone());
+    for (i, out) in ia.outputs.iter().enumerate() {
+        constraints.push(out.constraint.clone());
 
-        let out_datum = unpack_datum!(bcx, expr::trans(bcx, &**out));
-        if is_indirect {
+        let out_datum = unpack_datum!(bcx, expr::trans(bcx, &*out.expr));
+        if out.is_indirect {
             bcx = callee::trans_arg_datum(bcx,
-                                          expr_ty(bcx, &**out),
+                                          expr_ty(bcx, &*out.expr),
                                           out_datum,
                                           cleanup::CustomScope(temp_scope),
                                           callee::DontAutorefArg,
                                           &mut inputs);
-            if is_rw {
+            if out.is_rw {
                 ext_inputs.push(*inputs.last().unwrap());
                 ext_constraints.push(i.to_string());
             }
         } else {
             output_types.push(type_of::type_of(bcx.ccx(), out_datum.ty));
             outputs.push(out_datum.val);
-            if is_rw {
+            if out.is_rw {
                 bcx = callee::trans_arg_datum(bcx,
-                                              expr_ty(bcx, &**out),
+                                              expr_ty(bcx, &*out.expr),
                                               out_datum,
                                               cleanup::CustomScope(temp_scope),
                                               callee::DontAutorefArg,

diff --git a/src/librustc_trans/trans/debuginfo/create_scope_map.rs b/src/librustc_trans/trans/debuginfo/create_scope_map.rs
index c8a66fb611d533bcce268f59e8c08e912b0f6516..c9bcfe23aea967982ae0f5348ebc436dd67e0bc9 100644 (file)
--- a/src/librustc_trans/trans/debuginfo/create_scope_map.rs
+++ b/src/librustc_trans/trans/debuginfo/create_scope_map.rs
@@ -480,8 +480,8 @@ fn walk_expr(cx: &CrateContext,
                 walk_expr(cx, &**exp, scope_stack, scope_map);
             }
 
-            for &(_, ref exp, _, _) in outputs {
-                walk_expr(cx, &**exp, scope_stack, scope_map);
+            for out in outputs {
+                walk_expr(cx, &*out.expr, scope_stack, scope_map);
             }
         }
     }

diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 722273ee0f8525a0611098f99243f93fec2f649f..e3439b6cf7fdeb4bd9362ac175d4bc47d6e1e17e 100644 (file)
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -3393,8 +3393,8 @@ fn check_expr_struct<'a, 'tcx>(fcx: &FnCtxt<'a,'tcx>,
           for &(_, ref input) in &ia.inputs {
               check_expr(fcx, &**input);
           }
-          for &(_, ref out, _, _) in &ia.outputs {
-              check_expr(fcx, &**out);
+          for out in &ia.outputs {
+              check_expr(fcx, &*out.expr);
           }
           fcx.write_nil(id);
       }

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index ac3e26d033582d8c366a3c9b23635fd7b32bdb8c..46110a3bee9b1a5263b19d9090337eb646a1df84 100644 (file)
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1458,11 +1458,19 @@ pub enum AsmDialect {
     Intel,
 }
 
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub struct InlineAsmOutput {
+    pub constraint: InternedString,
+    pub expr: P<Expr>,
+    pub is_rw: bool,
+    pub is_indirect: bool,
+}
+
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct InlineAsm {
     pub asm: InternedString,
     pub asm_str_style: StrStyle,
-    pub outputs: Vec<(InternedString, P<Expr>, bool, bool)>,
+    pub outputs: Vec<InlineAsmOutput>,
     pub inputs: Vec<(InternedString, P<Expr>)>,
     pub clobbers: Vec<InternedString>,
     pub volatile: bool,

diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index f643f0be276854216c290584caf7ff886fec9f38..b4f29f837263fdcef85b80945e45a5d57e7ab653 100644 (file)
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -126,7 +126,12 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
                     let is_rw = output.is_some();
                     let is_indirect = constraint.contains("*");
-                    outputs.push((output.unwrap_or(constraint), out, is_rw, is_indirect));
+                    outputs.push(ast::InlineAsmOutput {
+                        constraint: output.unwrap_or(constraint),
+                        expr: out,
+                        is_rw: is_rw,
+                        is_indirect: is_indirect,
+                    });
                 }
             }
             Inputs => {

diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 8619c3c0bdb7920b318be654b0ada9d8602a745a..c637813f07e5b1270496e086c64b750ce386f95f 100644 (file)
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -1303,8 +1303,13 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
                 inputs: inputs.move_map(|(c, input)| {
                     (c, folder.fold_expr(input))
                 }),
-                outputs: outputs.move_map(|(c, out, is_rw, is_indirect)| {
-                    (c, folder.fold_expr(out), is_rw, is_indirect)
+                outputs: outputs.move_map(|out| {
+                    InlineAsmOutput {
+                        constraint: out.constraint,
+                        expr: folder.fold_expr(out.expr),
+                        is_rw: out.is_rw,
+                        is_indirect: out.is_indirect,
+                    }
                 }),
                 asm: asm,
                 asm_str_style: asm_str_style,

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index a0b7df3e2e9ea25ae35ccc392e42c0128f63a5b9..a96908e23dba8f83ccd18b4c081459e853c8e2e5 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -2221,16 +2221,16 @@ fn print_expr_outer_attr_style(&mut self,
                 try!(self.word_space(":"));
 
                 try!(self.commasep(Inconsistent, &a.outputs,
-                                   |s, &(ref co, ref o, is_rw, _)| {
-                    match co.slice_shift_char() {
-                        Some(('=', operand)) if is_rw => {
+                                   |s, out| {
+                    match out.constraint.slice_shift_char() {
+                        Some(('=', operand)) if out.is_rw => {
                             try!(s.print_string(&format!("+{}", operand),
                                                 ast::CookedStr))
                         }
-                        _ => try!(s.print_string(&co, ast::CookedStr))
+                        _ => try!(s.print_string(&out.constraint, ast::CookedStr))
                     }
                     try!(s.popen());
-                    try!(s.print_expr(&**o));
+                    try!(s.print_expr(&*out.expr));
                     try!(s.pclose());
                     Ok(())
                 }));

diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 5ede6596e8f99a2d4d515f96a180d55c444b7a5e..22bf135f4f9779750e136ac6c5e6b8a2d96ad66e 100644 (file)
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -786,8 +786,8 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             for &(_, ref input) in &ia.inputs {
                 visitor.visit_expr(&input)
             }
-            for &(_, ref output, _, _) in &ia.outputs {
-                visitor.visit_expr(&output)
+            for output in &ia.outputs {
+                visitor.visit_expr(&output.expr)
             }
         }
     }