The scope of the unsafe block can be appropriately reduced

capnp/src/lib.rs

@@ -80,9 +80,9 @@ impl Word {
         let mut result: Vec<Word> = Vec::with_capacity(length);
         unsafe {
             result.set_len(length);
-            let p: *mut u8 = result.as_mut_ptr() as *mut u8;
-            core::ptr::write_bytes(p, 0u8, length * core::mem::size_of::<Word>());
         }
+            let p: *mut u8 = result.as_mut_ptr() as *mut u8;
+        unsafe { core::ptr::write_bytes(p, 0u8, length * core::mem::size_of::<Word>()) };
         result
     }
 

capnp/src/private/layout.rs

@@ -2727,16 +2727,16 @@ impl <'a> PointerBuilder<'a> {
             wire_helpers::set_struct_pointer(
                 self.arena,
                 self.segment_id, self.cap_table, self.pointer, *value, canonicalize)?;
+            }
             Ok(())
-        }
     }
 
     pub fn set_list(&self, value: &ListReader, canonicalize: bool) -> Result<()> {
         unsafe {
             wire_helpers::set_list_pointer(self.arena, self.segment_id,
                                            self.cap_table, self.pointer, *value, canonicalize)?;
+                                        }
             Ok(())
-        }
     }
 
     pub fn set_text(&self, value: &str) {
@@ -3102,33 +3102,33 @@ impl <'a> StructBuilder<'a> {
             return Ok(())
         }
 
-        unsafe {
+
             if self.data_size > shared_data_size {
                 // Since the target is larger than the source, make sure to zero out the extra bits that the
                 // source doesn't have.
                 if self.data_size == 1 {
                     self.set_bool_field(0, false);
                 } else {
-                    let unshared = self.data.offset((shared_data_size / BITS_PER_BYTE as u32) as isize);
-                    ptr::write_bytes(unshared, 0, ((self.data_size - shared_data_size) / BITS_PER_BYTE as u32) as usize);
+                    let unshared = unsafe { self.data.offset((shared_data_size / BITS_PER_BYTE as u32) as isize) };
+                    unsafe { ptr::write_bytes(unshared, 0, ((self.data_size - shared_data_size) / BITS_PER_BYTE as u32) as usize) };
                 }
             }
 
             // Copy over the shared part.
             if shared_data_size == 1 {
                 self.set_bool_field(0, other.get_bool_field(0));
             } else {
-                ptr::copy_nonoverlapping(other.data, self.data, (shared_data_size / BITS_PER_BYTE as u32) as usize);
+                unsafe { ptr::copy_nonoverlapping(other.data, self.data, (shared_data_size / BITS_PER_BYTE as u32) as usize) };
             }
 
             // Zero out all pointers in the target.
             for i in 0..self.pointer_count as isize {
-                wire_helpers::zero_object(self.arena, self.segment_id, self.pointers.offset(i) as *mut _);
+                unsafe { wire_helpers::zero_object(self.arena, self.segment_id, self.pointers.offset(i) as *mut _) };
             }
-            ptr::write_bytes(self.pointers, 0u8, self.pointer_count as usize);
+            unsafe { ptr::write_bytes(self.pointers, 0u8, self.pointer_count as usize) };
 
             for i in 0..shared_pointer_count as isize {
-                wire_helpers::copy_pointer(self.arena,
+                unsafe { wire_helpers::copy_pointer(self.arena,
                                            self.segment_id,
                                            self.cap_table,
                                            self.pointers.offset(i),
@@ -3137,9 +3137,9 @@ impl <'a> StructBuilder<'a> {
                                            other.cap_table,
                                            other.pointers.offset(i),
                                            other.nesting_limit,
-                                           false)?;
+                                           false)? };
             }
-        }
+
 
         Ok(())
     }

capnp/src/serialize_packed.rs

@@ -70,17 +70,17 @@ impl <R> Read for PackedRead<R> where R: BufRead {
 
         assert!(len % 8 == 0, "PackedRead reads must be word-aligned.");
 
+        let mut out = out_buf.as_mut_ptr();
+        let out_end: *mut u8 = out_buf.as_mut_ptr().wrapping_offset(len as isize);
+
+        let (mut in_ptr, mut in_end) = self.get_read_buffer()?;
+        let mut buffer_begin = in_ptr;
+        let mut size = ptr_sub(in_end, in_ptr);
+        if size == 0 {
+            return Ok(0);
+        }
+
         unsafe {
-            let mut out = out_buf.as_mut_ptr();
-            let out_end: *mut u8 = out_buf.as_mut_ptr().wrapping_offset(len as isize);
-
-            let (mut in_ptr, mut in_end) = self.get_read_buffer()?;
-            let mut buffer_begin = in_ptr;
-            let mut size = ptr_sub(in_end, in_ptr);
-            if size == 0 {
-                return Ok(0);
-            }
-
             loop {
                 let tag: u8;
 
@@ -222,13 +222,13 @@ struct PackedWrite<W> where W: Write {
 
 impl <W> Write for PackedWrite<W> where W: Write {
     fn write_all(&mut self, in_buf: &[u8]) -> Result<()> {
+        let mut buf_idx: usize = 0;
+        let mut buf: [u8; 64] = [0; 64];
+
+        let mut in_ptr: *const u8 = in_buf.as_ptr();
+        let in_end: *const u8 = in_buf.as_ptr().wrapping_offset(in_buf.len() as isize);
+
         unsafe {
-            let mut buf_idx: usize = 0;
-            let mut buf: [u8; 64] = [0; 64];
-
-            let mut in_ptr: *const u8 = in_buf.as_ptr();
-            let in_end: *const u8 = in_buf.as_ptr().wrapping_offset(in_buf.len() as isize);
-
             while in_ptr < in_end {
 
                 if buf_idx + 10 > buf.len() {