oh, rustfmt changes the result after merge

Author: cpetig

crates/core/src/abi.rs

@@ -1,8 +1,7 @@
 pub use wit_parser::abi::{AbiVariant, WasmSignature, WasmType};
 use wit_parser::{
     align_to_arch, Alignment, ArchitectureSize, ElementInfo, Enum, Flags, FlagsRepr, Function,
-    Handle, Int, Record, Resolve, Result_, SizeAlign, Tuple, Type, TypeDefKind, TypeId,
-    Variant,
+    Handle, Int, Record, Resolve, Result_, SizeAlign, Tuple, Type, TypeDefKind, TypeId, Variant,
 };
 
 // Helper macro for defining instructions without having to have tons of
@@ -970,38 +969,38 @@ impl<'a, B: Bindgen> Generator<'a, B> {
 
                 // If necessary we may need to prepare a return pointer for
                 // this ABI.
-                let dealloc_size_align =
-                    if let Some((params_size, params_align)) = params_size_align {
-                        let ElementInfo { size, align } =
-                            self.bindgen.sizes().record(func.result.iter());
-                        self.emit(&Instruction::AsyncMalloc { size, align });
-                        let ptr = self.stack.pop().unwrap();
+                let dealloc_size_align = if let Some((params_size, params_align)) =
+                    params_size_align
+                {
+                    let ElementInfo { size, align } =
+                        self.bindgen.sizes().record(func.result.iter());
+                    self.emit(&Instruction::AsyncMalloc { size, align });
+                    let ptr = self.stack.pop().unwrap();
+                    self.return_pointer = Some(ptr.clone());
+                    self.stack.push(ptr);
+
+                    assert_eq!(self.stack.len(), 2);
+                    self.emit(&Instruction::AsyncCallWasm {
+                        name: &format!("[async]{}", func.name),
+                        size: params_size,
+                        align: params_align,
+                    });
+                    Some((size, align))
+                } else {
+                    if self.variant == AbiVariant::GuestImport && sig.retptr {
+                        let ElementInfo { size, align } = self.bindgen.sizes().params(&func.result);
+                        let ptr = self.bindgen.return_pointer(size, align);
                         self.return_pointer = Some(ptr.clone());
                         self.stack.push(ptr);
+                    }
 
-                        assert_eq!(self.stack.len(), 2);
-                        self.emit(&Instruction::AsyncCallWasm {
-                            name: &format!("[async]{}", func.name),
-                            size: params_size,
-                            align: params_align,
-                        });
-                        Some((size, align))
-                    } else {
-                        if self.variant == AbiVariant::GuestImport && sig.retptr {
-                            let ElementInfo { size, align } =
-                                self.bindgen.sizes().params(&func.result);
-                            let ptr = self.bindgen.return_pointer(size, align);
-                            self.return_pointer = Some(ptr.clone());
-                            self.stack.push(ptr);
-                        }
-
-                        assert_eq!(self.stack.len(), sig.params.len());
-                        self.emit(&Instruction::CallWasm {
-                            name: &func.name,
-                            sig: &sig,
-                        });
-                        None
-                    };
+                    assert_eq!(self.stack.len(), sig.params.len());
+                    self.emit(&Instruction::CallWasm {
+                        name: &func.name,
+                        sig: &sig,
+                    });
+                    None
+                };
 
                 if !(sig.retptr || self.async_) {
                     // With no return pointer in use we can simply lift the
@@ -1143,11 +1142,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                                 nth: sig.params.len() - 1,
                             });
                             let ptr = self.stack.pop().unwrap();
-                            self.write_params_to_memory(
-                                &func.result,
-                                ptr,
-                                Default::default(),
-                            );
+                            self.write_params_to_memory(&func.result, ptr, Default::default());
                         }
 
                         // For a guest import this is a function defined in
@@ -1214,11 +1209,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
 
         self.emit(&Instruction::GetArg { nth: 0 });
         let addr = self.stack.pop().unwrap();
-        for (offset, ty) in self
-            .bindgen
-            .sizes()
-            .field_offsets(&func.result)
-        {
+        for (offset, ty) in self.bindgen.sizes().field_offsets(&func.result) {
             self.deallocate(ty, addr.clone(), offset);
         }
         self.emit(&Instruction::Return { func, amt: 0 });