edition: Eliminate blocks superseded by NLL

Before the new borrow checker in the 2018 edition, we sometimes used to
have to manually insert curly braced blocks to limit the scope of
borrows. These are no longer needed.

Details in:

https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/non-lexical-lifetimes.html

TEST=cargo check --all-features
TEST=local kokoro

Change-Id: I59f9f98dcc03c8790c53e080a527ad9b68c8d6f3
Reviewed-on: https://chromium-review.googlesource.com/1568075
Commit-Ready: David Tolnay <dtolnay@chromium.org>
Tested-by: David Tolnay <dtolnay@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>

2 files changed, 22 insertions, 30 deletions

diff --git a/data_model/src/lib.rs b/data_model/src/lib.rs
index 7d3fd46..8288c84 100644
--- a/data_model/src/lib.rs
+++ b/data_model/src/lib.rs
@@ -121,36 +121,30 @@ macro_rules! data_init_type {
             fn from_slice_alignment() {
                 let mut v = [0u8; 32];
                 $(
-                    let pre_len =  {
-                        let (pre, _, _) = unsafe { v.align_to::<$T>() };
-                        pre.len()
-                    };
-                    {
-                        let aligned_v = &mut v[pre_len..pre_len + size_of::<$T>()];
-                        {
-                            let from_aligned = $T::from_slice(aligned_v);
-                            assert_eq!(from_aligned, Some(&0));
-                        }
-                        {
-                            let from_aligned_mut = $T::from_mut_slice(aligned_v);
-                            assert_eq!(from_aligned_mut, Some(&mut 0));
-                        }
-                    }
+                    let (pre, _, _) = unsafe { v.align_to::<$T>() };
+                    let pre_len = pre.len();
+
+                    let aligned_v = &mut v[pre_len..pre_len + size_of::<$T>()];
+
+                    let from_aligned = $T::from_slice(aligned_v);
+                    assert_eq!(from_aligned, Some(&0));
+
+                    let from_aligned_mut = $T::from_mut_slice(aligned_v);
+                    assert_eq!(from_aligned_mut, Some(&mut 0));
+
                     for i in 1..size_of::<$T>() {
                         let begin = pre_len + i;
                         let end = begin + size_of::<$T>();
                         let unaligned_v = &mut v[begin..end];
-                        {
-                            let from_unaligned = $T::from_slice(unaligned_v);
-                            if align_of::<$T>() != 1 {
-                                assert_eq!(from_unaligned, None);
-                            }
+
+                        let from_unaligned = $T::from_slice(unaligned_v);
+                        if align_of::<$T>() != 1 {
+                            assert_eq!(from_unaligned, None);
                         }
-                        {
-                            let from_unaligned_mut = $T::from_mut_slice(unaligned_v);
-                            if align_of::<$T>() != 1 {
-                                assert_eq!(from_unaligned_mut, None);
-                            }
+
+                        let from_unaligned_mut = $T::from_mut_slice(unaligned_v);
+                        if align_of::<$T>() != 1 {
+                            assert_eq!(from_unaligned_mut, None);
                         }
                     }
                 )*
diff --git a/data_model/src/volatile_memory.rs b/data_model/src/volatile_memory.rs
index 27fe1ad..9bdc0f4 100644
--- a/data_model/src/volatile_memory.rs
+++ b/data_model/src/volatile_memory.rs
@@ -513,11 +513,9 @@ mod tests {
     #[test]
     fn ref_store() {
         let mut a = [0u8; 1];
-        {
-            let a_ref = &mut a[..];
-            let v_ref = a_ref.get_ref(0).unwrap();
-            v_ref.store(2u8);
-        }
+        let a_ref = &mut a[..];
+        let v_ref = a_ref.get_ref(0).unwrap();
+        v_ref.store(2u8);
         assert_eq!(a[0], 2);
     }