Use addr_of where applicable

Author: mulimoen

src/class.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 use std::mem;
-use std::ptr;
+use std::ptr::{self, addr_of};
 
 use crate::internal_prelude::*;
 
@@ -53,7 +53,7 @@ pub trait ObjectClass: Sized {
     unsafe fn cast_unchecked<T: ObjectClass>(self) -> T {
         // This method requires you to be 18 years or older to use it
         // (note: if it wasn't a trait method, it could be marked as const)
-        let obj = ptr::read((&self as *const Self).cast());
+        let obj = ptr::read(addr_of!(self).cast());
         mem::forget(self);
         obj
     }

src/dim.rs

@@ -72,7 +72,7 @@ macro_rules! impl_tuple {
             #[inline]
             fn dims(&self) -> Vec<Ix> {
                 unsafe {
-                    slice::from_raw_parts(self as *const _ as *const _, self.ndim())
+                    slice::from_raw_parts((self as *const Self).cast(), self.ndim())
                 }.iter().cloned().collect()
             }
         }

src/error.rs

@@ -3,7 +3,7 @@ use std::error::Error as StdError;
 use std::fmt;
 use std::ops::Deref;
 use std::panic;
-use std::ptr;
+use std::ptr::{self, addr_of_mut};
 
 use ndarray::ShapeError;
 
@@ -95,7 +95,7 @@ impl ErrorStack {
         }
 
         let mut data = CallbackData { stack: ExpandedErrorStack::new(), err: None };
-        let data_ptr: *mut c_void = (&mut data as *mut CallbackData).cast::<c_void>();
+        let data_ptr: *mut c_void = addr_of_mut!(data).cast::<c_void>();
 
         let stack_id = self.handle().id();
         h5lock!({

src/hl/attribute.rs

@@ -1,5 +1,6 @@
 use std::fmt::{self, Debug};
 use std::ops::Deref;
+use std::ptr::addr_of_mut;
 
 use hdf5_sys::{
     h5::{H5_index_t, H5_iter_order_t},
@@ -62,7 +63,7 @@ impl Attribute {
         let callback_fn: H5A_operator2_t = Some(attributes_callback);
         let iteration_position: *mut hsize_t = &mut { 0_u64 };
         let mut result: Vec<String> = Vec::new();
-        let other_data: *mut c_void = &mut result as *const _ as *mut c_void;
+        let other_data: *mut c_void = addr_of_mut!(result).cast();
 
         h5call!(H5Aiterate2(
             obj.handle().id(),

src/hl/dataset.rs

@@ -684,7 +684,7 @@ impl DatasetBuilderInner {
     ///
     /// This requires the `lzf` crate feature
     pub fn lzf(&mut self) {
-        self.with_dcpl(|pl| pl.lzf());
+        self.with_dcpl(DatasetCreateBuilder::lzf);
     }
 
     #[cfg(feature = "blosc")]

src/hl/dataspace.rs

@@ -145,7 +145,7 @@ impl Dataspace {
                     let mut len: size_t = 0;
                     h5try!(H5Sencode1(self.id(), ptr::null_mut(), &mut len as *mut _));
                     let mut buf = vec![0_u8; len];
-                    h5try!(H5Sencode1(self.id(), buf.as_mut_ptr().cast(), &mut len as *mut _));
+                    h5try!(H5Sencode1(self.id(), buf.as_mut_ptr().cast(), ptr::addr_of_mut!(len)));
                     Ok(buf)
                 })
             }

src/hl/datatype.rs

@@ -2,6 +2,7 @@ use std::borrow::Borrow;
 use std::cmp::{Ordering, PartialEq, PartialOrd};
 use std::fmt::{self, Debug, Display};
 use std::ops::Deref;
+use std::ptr::{addr_of, addr_of_mut};
 
 use hdf5_sys::h5t::{
     H5T_cdata_t, H5T_class_t, H5T_cset_t, H5T_order_t, H5T_sign_t, H5T_str_t, H5Tarray_create2,
@@ -171,8 +172,8 @@ impl Datatype {
         let dst = dst.borrow();
         let mut cdata = H5T_cdata_t::default();
         h5lock!({
-            let noop = H5Tfind(*H5T_NATIVE_INT, *H5T_NATIVE_INT, &mut (&mut cdata as *mut _));
-            if H5Tfind(self.id(), dst.id(), &mut (&mut cdata as *mut _)) == noop {
+            let noop = H5Tfind(*H5T_NATIVE_INT, *H5T_NATIVE_INT, &mut addr_of_mut!(cdata));
+            if H5Tfind(self.id(), dst.id(), &mut addr_of_mut!(cdata)) == noop {
                 Some(Conversion::NoOp)
             } else {
                 match H5Tcompiler_conv(self.id(), dst.id()) {
@@ -235,7 +236,7 @@ impl Datatype {
                     let mut members: Vec<EnumMember> = Vec::new();
                     for idx in 0..h5try!(H5Tget_nmembers(id)) as _ {
                         let mut value: u64 = 0;
-                        h5try!(H5Tget_member_value(id, idx, (&mut value as *mut u64).cast()));
+                        h5try!(H5Tget_member_value(id, idx, addr_of_mut!(value).cast()));
                         let name = H5Tget_member_name(id, idx);
                         members.push(EnumMember { name: string_from_cstr(name), value });
                         h5_free_memory(name.cast());
@@ -277,7 +278,7 @@ impl Datatype {
                     let ndims = h5try!(H5Tget_array_ndims(id));
                     if ndims == 1 {
                         let mut len: hsize_t = 0;
-                        h5try!(H5Tget_array_dims2(id, &mut len as *mut _));
+                        h5try!(H5Tget_array_dims2(id, addr_of_mut!(len)));
                         Ok(TD::FixedArray(Box::new(base_dt.to_descriptor()?), len as _))
                     } else {
                         Err("Multi-dimensional array datatypes are not supported".into())
@@ -344,15 +345,17 @@ impl Datatype {
                 }),
                 TD::Boolean => {
                     let bool_id = h5try!(H5Tenum_create(*H5T_NATIVE_INT8));
+                    let zero = 0_i8;
                     h5try!(H5Tenum_insert(
                         bool_id,
                         b"FALSE\0".as_ptr().cast(),
-                        (&0_i8 as *const i8).cast()
+                        addr_of!(zero).cast(),
                     ));
+                    let one = 1_i8;
                     h5try!(H5Tenum_insert(
                         bool_id,
                         b"TRUE\0".as_ptr().cast(),
-                        (&1_i8 as *const i8).cast()
+                        addr_of!(one).cast(),
                     ));
                     Ok(bool_id)
                 }
@@ -364,7 +367,7 @@ impl Datatype {
                         h5try!(H5Tenum_insert(
                             enum_id,
                             name.as_ptr(),
-                            (&member.value as *const u64).cast()
+                            addr_of!(member.value).cast()
                         ));
                     }
                     Ok(enum_id)
@@ -383,7 +386,7 @@ impl Datatype {
                 TD::FixedArray(ref ty, len) => {
                     let elem_dt = Self::from_descriptor(ty)?;
                     let dims = len as hsize_t;
-                    Ok(h5try!(H5Tarray_create2(elem_dt.id(), 1, &dims as *const _)))
+                    Ok(h5try!(H5Tarray_create2(elem_dt.id(), 1, addr_of!(dims))))
                 }
                 TD::FixedAscii(size) => string_type(Some(size), H5T_cset_t::H5T_CSET_ASCII),
                 TD::FixedUnicode(size) => string_type(Some(size), H5T_cset_t::H5T_CSET_UTF8),

src/hl/filters.rs

@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use std::ptr;
+use std::ptr::{self, addr_of_mut};
 
 use hdf5_sys::h5p::{
     H5Pget_filter2, H5Pget_nfilters, H5Pset_deflate, H5Pset_filter, H5Pset_fletcher32, H5Pset_nbit,
@@ -180,7 +180,7 @@ impl Filter {
             return FilterInfo::default();
         }
         let mut flags: c_uint = 0;
-        h5lock!(H5Zget_filter_info(filter_id, &mut flags as *mut _));
+        h5lock!(H5Zget_filter_info(filter_id, addr_of_mut!(flags)));
         FilterInfo {
             is_available: true,
             encode_enabled: flags & H5Z_FILTER_CONFIG_ENCODE_ENABLED != 0,
@@ -503,8 +503,8 @@ impl Filter {
                 let filter_id = h5try!(H5Pget_filter2(
                     plist_id,
                     idx as _,
-                    &mut flags as *mut _,
-                    &mut cd_nelmts as *mut _,
+                    addr_of_mut!(flags),
+                    addr_of_mut!(cd_nelmts),
                     cd_values.as_mut_ptr(),
                     name.len() as _,
                     name.as_mut_ptr(),

src/hl/filters/blosc.rs

@@ -1,4 +1,4 @@
-use std::ptr;
+use std::ptr::{self, addr_of_mut};
 use std::slice;
 
 use lazy_static::lazy_static;
@@ -25,7 +25,7 @@ const BLOSC_FILTER_NAME: &[u8] = b"blosc\0";
 pub const BLOSC_FILTER_ID: H5Z_filter_t = 32001;
 const BLOSC_FILTER_VERSION: c_uint = 2;
 
-const BLOSC_FILTER_INFO: H5Z_class2_t = H5Z_class2_t {
+const BLOSC_FILTER_INFO: &H5Z_class2_t = &H5Z_class2_t {
     version: H5Z_CLASS_T_VERS as _,
     id: BLOSC_FILTER_ID,
     encoder_present: 1,
@@ -41,7 +41,7 @@ lazy_static! {
         unsafe {
             blosc_init();
         }
-        let ret = unsafe { H5Zregister((&BLOSC_FILTER_INFO as *const H5Z_class2_t).cast()) };
+        let ret = unsafe { H5Zregister((BLOSC_FILTER_INFO as *const H5Z_class2_t).cast()) };
         if H5ErrorCode::is_err_code(ret) {
             return Err("Can't register Blosc filter");
         }
@@ -62,8 +62,8 @@ extern "C" fn set_local_blosc(dcpl_id: hid_t, type_id: hid_t, _space_id: hid_t)
         H5Pget_filter_by_id2(
             dcpl_id,
             BLOSC_FILTER_ID,
-            &mut flags as *mut _,
-            &mut nelmts as *mut _,
+            addr_of_mut!(flags),
+            addr_of_mut!(nelmts),
             values.as_mut_ptr(),
             0,
             ptr::null_mut(),
@@ -158,7 +158,7 @@ fn parse_blosc_cdata(cd_nelmts: size_t, cd_values: *const c_uint) -> Option<Blos
         cfg.doshuffle = cdata[5] as _;
     }
     if cdata.len() >= 7 {
-        let r = unsafe { blosc_compcode_to_compname(cdata[6] as _, &mut cfg.compname as *mut _) };
+        let r = unsafe { blosc_compcode_to_compname(cdata[6] as _, addr_of_mut!(cfg.compname)) };
         if r == -1 {
             let complist = string_from_cstr(unsafe { blosc_list_compressors() });
             let errmsg = format!(
@@ -221,9 +221,9 @@ unsafe fn filter_blosc_decompress(
     let (mut cbytes, mut blocksize): (size_t, size_t) = (0, 0);
     blosc_cbuffer_sizes(
         *buf,
-        &mut outbuf_size as *mut _,
-        &mut cbytes as *mut _,
-        &mut blocksize as *mut _,
+        addr_of_mut!(outbuf_size),
+        addr_of_mut!(cbytes),
+        addr_of_mut!(blocksize),
     );
     let outbuf = libc::malloc(outbuf_size);
     if outbuf.is_null() {

src/hl/filters/lzf.rs

@@ -1,4 +1,4 @@
-use std::ptr;
+use std::ptr::{self, addr_of_mut};
 use std::slice;
 
 use lazy_static::lazy_static;
@@ -15,7 +15,7 @@ const LZF_FILTER_NAME: &[u8] = b"lzf\0";
 pub const LZF_FILTER_ID: H5Z_filter_t = 32000;
 const LZF_FILTER_VERSION: c_uint = 4;
 
-const LZF_FILTER_INFO: H5Z_class2_t = H5Z_class2_t {
+const LZF_FILTER_INFO: &H5Z_class2_t = &H5Z_class2_t {
     version: H5Z_CLASS_T_VERS as _,
     id: LZF_FILTER_ID,
     encoder_present: 1,
@@ -28,7 +28,7 @@ const LZF_FILTER_INFO: H5Z_class2_t = H5Z_class2_t {
 
 lazy_static! {
     static ref LZF_INIT: Result<(), &'static str> = {
-        let ret = unsafe { H5Zregister((&LZF_FILTER_INFO as *const H5Z_class2_t).cast()) };
+        let ret = unsafe { H5Zregister((LZF_FILTER_INFO as *const H5Z_class2_t).cast()) };
         if H5ErrorCode::is_err_code(ret) {
             return Err("Can't register LZF filter");
         }
@@ -49,8 +49,8 @@ extern "C" fn set_local_lzf(dcpl_id: hid_t, type_id: hid_t, _space_id: hid_t) ->
         H5Pget_filter_by_id2(
             dcpl_id,
             LZF_FILTER_ID,
-            &mut flags as *mut _,
-            &mut nelmts as *mut _,
+            addr_of_mut!(flags),
+            addr_of_mut!(nelmts),
             values.as_mut_ptr(),
             0,
             ptr::null_mut(),

src/hl/group.rs

@@ -1,6 +1,7 @@
 use std::fmt::{self, Debug};
 use std::ops::Deref;
 use std::panic;
+use std::ptr::addr_of_mut;
 
 use hdf5_sys::{
     h5::{hsize_t, H5_index_t, H5_iter_order_t},
@@ -339,7 +340,7 @@ impl Group {
 
         // Store our references on the heap
         let mut vtable = Vtable { f: &mut op, d: &mut val };
-        let other_data = (&mut vtable as *mut Vtable<_, _>).cast::<c_void>();
+        let other_data = addr_of_mut!(vtable).cast::<c_void>();
 
         h5call!(H5Literate(
             self.id(),

src/hl/plist.rs

@@ -1,7 +1,7 @@
 use std::fmt::{self, Debug, Display};
 use std::ops::Deref;
 use std::panic;
-use std::ptr;
+use std::ptr::{self, addr_of_mut};
 use std::str::FromStr;
 
 use hdf5_sys::h5p::{
@@ -184,7 +184,7 @@ impl PropertyList {
         }
 
         let mut data = Vec::new();
-        let data_ptr: *mut c_void = (&mut data as *mut Vec<_>).cast();
+        let data_ptr: *mut c_void = addr_of_mut!(data).cast();
 
         h5lock!(H5Piterate(self.id(), ptr::null_mut(), Some(callback), data_ptr));
         data

src/hl/plist/dataset_create.rs

@@ -2,7 +2,7 @@
 
 use std::fmt::{self, Debug};
 use std::ops::Deref;
-use std::ptr;
+use std::ptr::{self, addr_of_mut};
 
 #[cfg(feature = "1.10.0")]
 use bitflags::bitflags;
@@ -809,8 +809,8 @@ impl DatasetCreate {
                     idx as _,
                     NAME_LEN as _,
                     name.as_mut_ptr(),
-                    &mut offset as *mut _,
-                    &mut size as *mut _,
+                    addr_of_mut!(offset),
+                    addr_of_mut!(size),
                 ));
                 #[allow(clippy::absurd_extreme_comparisons)]
                 external.push(ExternalFile {

src/hl/plist/file_access.rs

@@ -13,7 +13,7 @@ use std::fmt::{self, Debug};
 use std::iter;
 use std::mem;
 use std::ops::Deref;
-use std::ptr;
+use std::ptr::{self, addr_of, addr_of_mut};
 
 use bitflags::bitflags;
 
@@ -1449,7 +1449,8 @@ impl FileAccessBuilder {
                 h5try!(H5Pset_evict_on_close(id, hbool_t::from(v)));
             }
             if let Some(v) = self.mdc_image_config {
-                h5try!(H5Pset_mdc_image_config(id, &v.into() as *const _));
+                let v = v.into();
+                h5try!(H5Pset_mdc_image_config(id, addr_of!(v)));
             }
         }
         if let Some(v) = self.sieve_buf_size {
@@ -1480,7 +1481,8 @@ impl FileAccessBuilder {
             }
         }
         if let Some(ref v) = self.mdc_config {
-            h5try!(H5Pset_mdc_config(id, &v.clone().into() as *const _));
+            let v = v.clone().into();
+            h5try!(H5Pset_mdc_config(id, addr_of!(v)));
         }
         Ok(())
     }
@@ -1516,7 +1518,7 @@ impl FileAccess {
         let mut drv = CoreDriver::default();
         let mut increment: size_t = 0;
         let mut filebacked: hbool_t = 0;
-        h5try!(H5Pget_fapl_core(self.id(), &mut increment as *mut _, &mut filebacked as *mut _));
+        h5try!(H5Pget_fapl_core(self.id(), addr_of_mut!(increment), addr_of_mut!(filebacked)));
         drv.increment = increment as _;
         drv.filebacked = filebacked > 0;
         #[cfg(feature = "1.8.13")]
@@ -1525,8 +1527,8 @@ impl FileAccess {
             let mut page_size: size_t = 0;
             h5try!(H5Pget_core_write_tracking(
                 self.id(),
-                &mut is_enabled as *mut _,
-                &mut page_size as *mut _,
+                addr_of_mut!(is_enabled),
+                addr_of_mut!(page_size),
             ));
             if is_enabled > 0 {
                 drv.write_tracking = page_size;
@@ -1558,7 +1560,7 @@ impl FileAccess {
             memb_fapl.as_mut_ptr(),
             memb_name.as_mut_ptr(),
             memb_addr.as_mut_ptr(),
-            &mut relax as *mut _,
+            addr_of_mut!(relax),
         ));
         let mut mapping: [u8; N] = unsafe { mem::zeroed() };
         let mut layout = MultiLayout::default();

src/util.rs

@@ -21,7 +21,8 @@ pub fn to_cstring<S: Borrow<str>>(string: S) -> Result<CString> {
 /// Convert a fixed-length (possibly zero-terminated) char buffer to a string.
 pub fn string_from_fixed_bytes(bytes: &[c_char], len: usize) -> String {
     let len = bytes.iter().position(|&c| c == 0).unwrap_or(len);
-    let s = unsafe { str::from_utf8_unchecked(&*(&bytes[..len] as *const _ as *const _)) };
+    let bytes = &bytes[..len];
+    let s = unsafe { str::from_utf8_unchecked(&*(bytes as *const [c_char] as *const [u8])) };
     s.to_owned()
 }