Fix Clippy issues (#127)

* Remove unnecessary parentheses
* Remove deprecated `Error::description` (closes #123)
* Avoid zero initialization of `AEffect`
* Use `to_bits` to get bits from `f32`

Author: askeksa

examples/simple_host.rs

@@ -1,7 +1,6 @@
 extern crate vst;
 
 use std::env;
-use std::error::Error;
 use std::path::Path;
 use std::process;
 use std::sync::{Arc, Mutex};
@@ -33,8 +32,8 @@ fn main() {
     println!("Loading {}...", path.to_str().unwrap());
 
     // Load the plugin
-    let mut loader = PluginLoader::load(path, Arc::clone(&host))
-        .unwrap_or_else(|e| panic!("Failed to load plugin: {}", e.description()));
+    let mut loader =
+        PluginLoader::load(path, Arc::clone(&host)).unwrap_or_else(|e| panic!("Failed to load plugin: {}", e));
 
     // Create an instance of the plugin
     let mut instance = loader.instance().unwrap();

src/host.rs

@@ -245,23 +245,19 @@ pub enum PluginLoadError {
 
 impl fmt::Display for PluginLoadError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
-    }
-}
-
-impl Error for PluginLoadError {
-    fn description(&self) -> &str {
         use self::PluginLoadError::*;
-
-        match *self {
+        let description = match self {
             InvalidPath => "Could not open the requested path",
             NotAPlugin => "The given path does not contain a VST2.4 compatible library",
             InstanceFailed => "Failed to create a plugin instance",
             InvalidApiVersion => "The plugin API version is not compatible with this library",
-        }
+        };
+        write!(f, "{}", description)
     }
 }
 
+impl Error for PluginLoadError {}
+
 /// Wrapper for an externally loaded VST plugin.
 ///
 /// The only functionality this struct provides is loading plugins, which can be done via the

src/interfaces.rs

@@ -241,7 +241,7 @@ pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr
                 editor.key_down(KeyCode {
                     character: index as u8 as char,
                     key: Key::from(value),
-                    modifier: unsafe { mem::transmute::<f32, i32>(opt) } as u8,
+                    modifier: opt.to_bits() as u8,
                 });
             }
         }
@@ -250,7 +250,7 @@ pub fn dispatch(effect: *mut AEffect, opcode: i32, index: i32, value: isize, ptr
                 editor.key_up(KeyCode {
                     character: index as u8 as char,
                     key: Key::from(value),
-                    modifier: unsafe { mem::transmute::<f32, i32>(opt) } as u8,
+                    modifier: opt.to_bits() as u8,
                 });
             }
         }

src/lib.rs

@@ -113,7 +113,7 @@ extern crate log;
 #[macro_use]
 extern crate bitflags;
 
-use std::{mem, ptr};
+use std::ptr;
 
 /// Implements `From` and `Into` for enums with `#[repr(usize)]`. Useful for interfacing with C
 /// enums.
@@ -188,88 +188,98 @@ macro_rules! plugin_main {
 /// Initializes a VST plugin and returns a raw pointer to an AEffect struct.
 #[doc(hidden)]
 pub fn main<T: Plugin + Default>(callback: HostCallbackProc) -> *mut AEffect {
-    // Create a Box containing a zeroed AEffect. This is transmuted into a *mut pointer so that it
-    // can be passed into the HostCallback `wrap` method. The AEffect is then updated after the vst
-    // object is created so that the host still contains a raw pointer to the AEffect struct.
-    let effect = unsafe { Box::into_raw(Box::new(mem::MaybeUninit::zeroed().assume_init())) };
+    // Initialize as much of the AEffect as we can before creating the plugin.
+    // In particular, initialize all the function pointers, since initializing
+    // these to zero is undefined behavior.
+    let boxed_effect = Box::new(AEffect {
+        magic: VST_MAGIC,
+        dispatcher: interfaces::dispatch, // fn pointer
 
-    let host = HostCallback::wrap(callback, effect);
-    if host.vst_version() == 0 {
-        // TODO: Better criteria would probably be useful here...
-        return ptr::null_mut();
-    }
+        _process: interfaces::process_deprecated, // fn pointer
 
-    trace!("Creating VST plugin instance...");
-    let mut plugin = T::new(host);
-    let info = plugin.get_info();
-    let params = plugin.get_parameter_object();
-    let editor = plugin.get_editor();
+        setParameter: interfaces::set_parameter, // fn pointer
+        getParameter: interfaces::get_parameter, // fn pointer
 
-    // Update AEffect in place
-    unsafe {
-        *effect = AEffect {
-            magic: VST_MAGIC,
-            dispatcher: interfaces::dispatch, // fn pointer
-
-            _process: interfaces::process_deprecated, // fn pointer
-
-            setParameter: interfaces::set_parameter, // fn pointer
-            getParameter: interfaces::get_parameter, // fn pointer
-
-            numPrograms: info.presets,
-            numParams: info.parameters,
-            numInputs: info.inputs,
-            numOutputs: info.outputs,
+        numPrograms: 0, // To be updated with plugin specific value.
+        numParams: 0,   // To be updated with plugin specific value.
+        numInputs: 0,   // To be updated with plugin specific value.
+        numOutputs: 0,  // To be updated with plugin specific value.
 
-            flags: {
-                use api::PluginFlags;
+        flags: 0, // To be updated with plugin specific value.
 
-                let mut flag = PluginFlags::CAN_REPLACING;
+        reserved1: 0,
+        reserved2: 0,
 
-                if info.f64_precision {
-                    flag |= PluginFlags::CAN_DOUBLE_REPLACING;
-                }
+        initialDelay: 0, // To be updated with plugin specific value.
 
-                if editor.is_some() {
-                    flag |= PluginFlags::HAS_EDITOR;
-                }
+        _realQualities: 0,
+        _offQualities: 0,
+        _ioRatio: 0.0,
 
-                if info.preset_chunks {
-                    flag |= PluginFlags::PROGRAM_CHUNKS;
-                }
+        object: ptr::null_mut(),
+        user: ptr::null_mut(),
 
-                if let plugin::Category::Synth = info.category {
-                    flag |= PluginFlags::IS_SYNTH;
-                }
+        uniqueId: 0, // To be updated with plugin specific value.
+        version: 0,  // To be updated with plugin specific value.
 
-                if info.silent_when_stopped {
-                    flag |= PluginFlags::NO_SOUND_IN_STOP;
-                }
+        processReplacing: interfaces::process_replacing, // fn pointer
+        processReplacingF64: interfaces::process_replacing_f64, //fn pointer
 
-                flag.bits()
-            },
+        future: [0u8; 56],
+    });
+    let raw_effect = Box::into_raw(boxed_effect);
 
-            reserved1: 0,
-            reserved2: 0,
+    let host = HostCallback::wrap(callback, raw_effect);
+    if host.vst_version() == 0 {
+        // TODO: Better criteria would probably be useful here...
+        return ptr::null_mut();
+    }
 
-            initialDelay: info.initial_delay,
+    trace!("Creating VST plugin instance...");
+    let mut plugin = T::new(host);
+    let info = plugin.get_info();
+    let params = plugin.get_parameter_object();
+    let editor = plugin.get_editor();
 
-            _realQualities: 0,
-            _offQualities: 0,
-            _ioRatio: 0.0,
+    // Update AEffect in place
+    let effect = unsafe { &mut *raw_effect };
+    effect.numPrograms = info.presets;
+    effect.numParams = info.parameters;
+    effect.numInputs = info.inputs;
+    effect.numOutputs = info.outputs;
+    effect.flags = {
+        use api::PluginFlags;
+
+        let mut flag = PluginFlags::CAN_REPLACING;
+
+        if info.f64_precision {
+            flag |= PluginFlags::CAN_DOUBLE_REPLACING;
+        }
 
-            object: Box::into_raw(Box::new(Box::new(plugin) as Box<dyn Plugin>)) as *mut _,
-            user: Box::into_raw(Box::new(PluginCache::new(&info, params, editor))) as *mut _,
+        if editor.is_some() {
+            flag |= PluginFlags::HAS_EDITOR;
+        }
 
-            uniqueId: info.unique_id,
-            version: info.version,
+        if info.preset_chunks {
+            flag |= PluginFlags::PROGRAM_CHUNKS;
+        }
 
-            processReplacing: interfaces::process_replacing, // fn pointer
-            processReplacingF64: interfaces::process_replacing_f64, //fn pointer
+        if let plugin::Category::Synth = info.category {
+            flag |= PluginFlags::IS_SYNTH;
+        }
 
-            future: [0u8; 56],
+        if info.silent_when_stopped {
+            flag |= PluginFlags::NO_SOUND_IN_STOP;
         }
+
+        flag.bits()
     };
+    effect.initialDelay = info.initial_delay;
+    effect.object = Box::into_raw(Box::new(Box::new(plugin) as Box<dyn Plugin>)) as *mut _;
+    effect.user = Box::into_raw(Box::new(PluginCache::new(&info, params, editor))) as *mut _;
+    effect.uniqueId = info.unique_id;
+    effect.version = info.version;
+
     effect
 }
 

src/plugin.rs

@@ -957,7 +957,7 @@ impl Host for HostCallback {
 
         match ptr {
             0 => None,
-            ptr => Some(unsafe { (*(ptr as *const TimeInfo)) }),
+            ptr => Some(unsafe { *(ptr as *const TimeInfo) }),
         }
     }