rustfmt v0.5.0

src/libcretonne/repr.rs

@@ -148,8 +148,8 @@ impl Function {
         // Update the second_result pointer in `inst`.
         if head != NO_VALUE {
             *self.inst_mut(inst)
-                 .second_result_mut()
-                 .expect("instruction format doesn't allow multiple results") = head;
+                .second_result_mut()
+                .expect("instruction format doesn't allow multiple results") = head;
         }
         *self.inst_mut(inst).first_type_mut() = first_type;
 

src/libcretonne/types.rs

@@ -66,7 +66,7 @@ pub const B64: Type = Type(11);
 
 impl Type {
     /// Get the lane type of this SIMD vector type.
-    /// 
+    ///
     /// A scalar type is the same as a SIMD vector type with one lane, so it returns itself.
     pub fn lane_type(self) -> Type {
         Type(self.0 & 0x0f)

src/libreader/parser.rs

@@ -608,7 +608,7 @@ impl<'a> Parser<'a> {
                     // explicitly. It is unfortunate that the correctness of IL depends on the
                     // layout of the blocks.
                     let ctrl_src_value = inst_data.typevar_operand()
-                                                  .expect("Constraints <-> Format inconsistency");
+                        .expect("Constraints <-> Format inconsistency");
                     ctx.function.value_type(match ctx.values.get(&ctrl_src_value) {
                         Some(&v) => v,
                         None => {
@@ -791,8 +791,8 @@ mod tests {
         assert_eq!(sig.return_types.len(), 0);
 
         let sig2 = Parser::new("(i8 inreg uext, f32, f64) -> i32 sext, f64")
-                       .parse_signature()
-                       .unwrap();
+            .parse_signature()
+            .unwrap();
         assert_eq!(sig2.to_string(),
                    "(i8 uext inreg, f32, f64) -> i32 sext, f64");
 
@@ -811,8 +811,8 @@ mod tests {
                                   ss3 = stack_slot 13
                                   ss1 = stack_slot 1
                                 }")
-                       .parse_function()
-                       .unwrap();
+            .parse_function()
+            .unwrap();
         assert_eq!(func.name, "foo");
         let mut iter = func.stack_slot_iter();
         let ss0 = iter.next().unwrap();
@@ -840,8 +840,8 @@ mod tests {
                                 ebb0:
                                 ebb4(vx3: i32):
                                 }")
-                       .parse_function()
-                       .unwrap();
+            .parse_function()
+            .unwrap();
         assert_eq!(func.name, "ebbs");
 
         let mut ebbs = func.ebbs_numerically();