Merge pull request #491 from GuillaumeGomez/warnings

Fix dyn and import warnings

Author: sdroege

src/byte_array.rs

@@ -107,9 +107,9 @@ impl ByteArray {
     pub fn sort<F: FnMut(&u8, &u8) -> Ordering>(&self, compare_func: F) {
         unsafe {
             let mut func = compare_func;
-            let func_obj: &mut (FnMut(&u8, &u8) -> Ordering) = &mut func;
+            let func_obj: &mut (dyn FnMut(&u8, &u8) -> Ordering) = &mut func;
             let func_ptr =
-                &func_obj as *const &mut (FnMut(&u8, &u8) -> Ordering) as glib_sys::gpointer;
+                &func_obj as *const &mut (dyn FnMut(&u8, &u8) -> Ordering) as glib_sys::gpointer;
 
             glib_sys::g_byte_array_sort_with_data(
                 self.to_glib_none().0,
@@ -125,7 +125,7 @@ unsafe extern "C" fn compare_func_trampoline(
     b: glib_sys::gconstpointer,
     func: glib_sys::gpointer,
 ) -> i32 {
-    let func = func as *mut &mut (FnMut(&u8, &u8) -> Ordering);
+    let func = func as *mut &mut (dyn FnMut(&u8, &u8) -> Ordering);
 
     let a = &*(a as *const u8);
     let b = &*(b as *const u8);

src/closure.rs

@@ -83,7 +83,7 @@ impl Closure {
     }
 
     #[allow(clippy::redundant_closure)]
-    pub fn invoke(&self, values: &[&ToValue]) -> Option<Value> {
+    pub fn invoke(&self, values: &[&dyn ToValue]) -> Option<Value> {
         let mut result = unsafe { Value::uninitialized() };
 
         let v_args: Vec<Value>;

src/object.rs

@@ -858,7 +858,7 @@ glib_object_wrapper!(@object
 );
 
 impl Object {
-    pub fn new(type_: Type, properties: &[(&str, &ToValue)]) -> Result<Object, BoolError> {
+    pub fn new(type_: Type, properties: &[(&str, &dyn ToValue)]) -> Result<Object, BoolError> {
         use std::ffi::CString;
 
         if !type_.is_a(&Object::static_type()) {
@@ -898,7 +898,7 @@ pub trait ObjectExt: ObjectType {
     fn get_type(&self) -> Type;
     fn get_object_class(&self) -> &ObjectClass;
 
-    fn set_property<'a, N: Into<&'a str>>(&self, property_name: N, value: &ToValue) -> Result<(), BoolError>;
+    fn set_property<'a, N: Into<&'a str>>(&self, property_name: N, value: &dyn ToValue) -> Result<(), BoolError>;
     fn get_property<'a, N: Into<&'a str>>(&self, property_name: N) -> Result<Value, BoolError>;
     fn has_property<'a, N: Into<&'a str>>(&self, property_name: N, type_: Option<Type>) -> Result<(), BoolError>;
     fn get_property_type<'a, N: Into<&'a str>>(&self, property_name: N) -> Option<Type>;
@@ -913,7 +913,7 @@ pub trait ObjectExt: ObjectType {
         where N: Into<&'a str>, F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static;
     unsafe fn connect_unsafe<'a, N, F>(&self, signal_name: N, after: bool, callback: F) -> Result<SignalHandlerId, BoolError>
         where N: Into<&'a str>, F: Fn(&[Value]) -> Option<Value>;
-    fn emit<'a, N: Into<&'a str>>(&self, signal_name: N, args: &[&ToValue]) -> Result<Option<Value>, BoolError>;
+    fn emit<'a, N: Into<&'a str>>(&self, signal_name: N, args: &[&dyn ToValue]) -> Result<Option<Value>, BoolError>;
     fn disconnect(&self, handler_id: SignalHandlerId);
 
     fn connect_notify<F: Fn(&Self, &::ParamSpec) + Send + Sync + 'static>(&self, name: Option<&str>, f: F) -> SignalHandlerId;
@@ -945,7 +945,7 @@ impl<T: ObjectType> ObjectExt for T {
         }
     }
 
-    fn set_property<'a, N: Into<&'a str>>(&self, property_name: N, value: &ToValue) -> Result<(), BoolError> {
+    fn set_property<'a, N: Into<&'a str>>(&self, property_name: N, value: &dyn ToValue) -> Result<(), BoolError> {
         let property_name = property_name.into();
         let mut property_value = value.to_value();
 
@@ -1195,7 +1195,7 @@ impl<T: ObjectType> ObjectExt for T {
         }
     }
 
-    fn emit<'a, N: Into<&'a str>>(&self, signal_name: N, args: &[&ToValue]) -> Result<Option<Value>, BoolError> {
+    fn emit<'a, N: Into<&'a str>>(&self, signal_name: N, args: &[&dyn ToValue]) -> Result<Option<Value>, BoolError> {
         let signal_name: &str = signal_name.into();
         unsafe {
             let type_ = self.get_type();

src/source_futures.rs

@@ -104,14 +104,17 @@ impl<T, F> Drop for SourceFuture<T, F> {
 /// Create a `Future` that will resolve after the given number of milliseconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn timeout_future(value: u32) -> Box<Future<Output = ()> + std::marker::Unpin + Send> {
+pub fn timeout_future(value: u32) -> Box<dyn Future<Output = ()> + std::marker::Unpin + Send> {
     timeout_future_with_priority(::PRIORITY_DEFAULT, value)
 }
 
 /// Create a `Future` that will resolve after the given number of milliseconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn timeout_future_with_priority(priority: Priority, value: u32) -> Box<Future<Output = ()> + std::marker::Unpin + Send> {
+pub fn timeout_future_with_priority(
+    priority: Priority,
+    value: u32,
+) -> Box<dyn Future<Output = ()> + std::marker::Unpin + Send> {
     Box::new(SourceFuture::new(move |send| {
         let mut send = Some(send);
         ::timeout_source_new(value, None, priority, move || {
@@ -124,7 +127,9 @@ pub fn timeout_future_with_priority(priority: Priority, value: u32) -> Box<Futur
 /// Create a `Future` that will resolve after the given number of seconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn timeout_future_seconds(value: u32) -> Box<Future<Output = ()> + std::marker::Unpin + Send> {
+pub fn timeout_future_seconds(
+    value: u32,
+) -> Box<dyn Future<Output = ()> + std::marker::Unpin + Send> {
     timeout_future_seconds_with_priority(::PRIORITY_DEFAULT, value)
 }
 
@@ -134,7 +139,7 @@ pub fn timeout_future_seconds(value: u32) -> Box<Future<Output = ()> + std::mark
 pub fn timeout_future_seconds_with_priority(
     priority: Priority,
     value: u32,
-) -> Box<Future<Output = ()> + std::marker::Unpin + Send> {
+) -> Box<dyn Future<Output = ()> + std::marker::Unpin + Send> {
     Box::new(SourceFuture::new(move |send| {
         let mut send = Some(send);
         ::timeout_source_new_seconds(value, None, priority, move || {
@@ -149,7 +154,9 @@ pub fn timeout_future_seconds_with_priority(
 /// The `Future` will resolve to the pid of the child process and the exit code.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn child_watch_future(pid: ::Pid) -> Box<Future<Output = (::Pid, i32)> + std::marker::Unpin + Send> {
+pub fn child_watch_future(
+    pid: ::Pid,
+) -> Box<dyn Future<Output = (::Pid, i32)> + std::marker::Unpin + Send> {
     child_watch_future_with_priority(::PRIORITY_DEFAULT, pid)
 }
 
@@ -161,7 +168,7 @@ pub fn child_watch_future(pid: ::Pid) -> Box<Future<Output = (::Pid, i32)> + std
 pub fn child_watch_future_with_priority(
     priority: Priority,
     pid: ::Pid,
-) -> Box<Future<Output = (::Pid, i32)> + std::marker::Unpin + Send> {
+) -> Box<dyn Future<Output = (::Pid, i32)> + std::marker::Unpin + Send> {
     Box::new(SourceFuture::new(move |send| {
         let mut send = Some(send);
         ::child_watch_source_new(pid, None, priority, move |pid, code| {
@@ -174,15 +181,18 @@ pub fn child_watch_future_with_priority(
 /// Create a `Future` that will resolve once the given UNIX signal is raised
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn unix_signal_future(signum: i32) -> Box<Future<Output = ()> + std::marker::Unpin + Send> {
+pub fn unix_signal_future(signum: i32) -> Box<dyn Future<Output = ()> + std::marker::Unpin + Send> {
     unix_signal_future_with_priority(::PRIORITY_DEFAULT, signum)
 }
 
 #[cfg(any(unix, feature = "dox"))]
 /// Create a `Future` that will resolve once the given UNIX signal is raised
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn unix_signal_future_with_priority(priority: Priority, signum: i32) -> Box<Future<Output = ()> + std::marker::Unpin + Send> {
+pub fn unix_signal_future_with_priority(
+    priority: Priority,
+    signum: i32,
+) -> Box<dyn Future<Output = ()> + std::marker::Unpin + Send> {
     Box::new(SourceFuture::new(move |send| {
         let mut send = Some(send);
         ::unix_signal_source_new(signum, None, priority, move || {
@@ -283,14 +293,17 @@ impl<T, F> Drop for SourceStream<T, F> {
 /// Create a `Stream` that will provide a value every given number of milliseconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn interval_stream(value: u32) -> Box<Stream<Item = ()> + std::marker::Unpin + Send> {
+pub fn interval_stream(value: u32) -> Box<dyn Stream<Item = ()> + std::marker::Unpin + Send> {
     interval_stream_with_priority(::PRIORITY_DEFAULT, value)
 }
 
 /// Create a `Stream` that will provide a value every given number of milliseconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn interval_stream_with_priority(priority: Priority, value: u32) -> Box<Stream<Item = ()> + std::marker::Unpin + Send> {
+pub fn interval_stream_with_priority(
+    priority: Priority,
+    value: u32,
+) -> Box<dyn Stream<Item = ()> + std::marker::Unpin + Send> {
     Box::new(SourceStream::new(move |send| {
         ::timeout_source_new(value, None, priority, move || {
             if send.unbounded_send(()).is_err() {
@@ -305,7 +318,9 @@ pub fn interval_stream_with_priority(priority: Priority, value: u32) -> Box<Stre
 /// Create a `Stream` that will provide a value every given number of seconds.
 ///
 /// The `Stream` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn interval_stream_seconds(value: u32) -> Box<Stream<Item = ()> + std::marker::Unpin + Send> {
+pub fn interval_stream_seconds(
+    value: u32,
+) -> Box<dyn Stream<Item = ()> + std::marker::Unpin + Send> {
     interval_stream_seconds_with_priority(::PRIORITY_DEFAULT, value)
 }
 
@@ -315,7 +330,7 @@ pub fn interval_stream_seconds(value: u32) -> Box<Stream<Item = ()> + std::marke
 pub fn interval_stream_seconds_with_priority(
     priority: Priority,
     value: u32,
-) -> Box<Stream<Item = ()> + std::marker::Unpin + Send> {
+) -> Box<dyn Stream<Item = ()> + std::marker::Unpin + Send> {
     Box::new(SourceStream::new(move |send| {
         ::timeout_source_new_seconds(value, None, priority, move || {
             if send.unbounded_send(()).is_err() {
@@ -331,15 +346,18 @@ pub fn interval_stream_seconds_with_priority(
 /// Create a `Stream` that will provide a value whenever the given UNIX signal is raised
 ///
 /// The `Stream` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn unix_signal_stream(signum: i32) -> Box<Stream<Item = ()> + std::marker::Unpin + Send> {
+pub fn unix_signal_stream(signum: i32) -> Box<dyn Stream<Item = ()> + std::marker::Unpin + Send> {
     unix_signal_stream_with_priority(::PRIORITY_DEFAULT, signum)
 }
 
 #[cfg(any(unix, feature = "dox"))]
 /// Create a `Stream` that will provide a value whenever the given UNIX signal is raised
 ///
 /// The `Stream` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn unix_signal_stream_with_priority(priority: Priority, signum: i32) -> Box<Stream<Item = ()> + std::marker::Unpin + Send> {
+pub fn unix_signal_stream_with_priority(
+    priority: Priority,
+    signum: i32,
+) -> Box<dyn Stream<Item = ()> + std::marker::Unpin + Send> {
     Box::new(SourceStream::new(move |send| {
         ::unix_signal_source_new(signum, None, priority, move || {
             if send.unbounded_send(()).is_err() {

src/translate.rs

@@ -401,7 +401,6 @@ fn path_to_c(path: &Path) -> CString {
     // Paths on UNIX must not contain NUL bytes, in which case the conversion
     // to a CString would fail. The only thing we can do then is to panic, as passing
     // NULL or the empty string to GLib would cause undefined behaviour.
-    use std::os::unix::ffi::OsStrExt;
     CString::new(path.as_os_str().as_bytes())
         .expect("Invalid path with NUL bytes")
 }
@@ -440,7 +439,6 @@ fn os_str_to_c(s: &OsStr) -> CString {
     // OS string on UNIX must not contain NUL bytes, in which case the conversion
     // to a CString would fail. The only thing we can do then is to panic, as passing
     // NULL or the empty string to GLib would cause undefined behaviour.
-    use std::os::unix::ffi::OsStrExt;
     CString::new(s.as_bytes())
         .expect("Invalid OS String with NUL bytes")
 }

src/value.rs

@@ -290,7 +290,7 @@ impl<'a> ToGlibPtrMut<'a, *mut gobject_sys::GValue> for Value {
 }
 
 #[doc(hidden)]
-impl<'a> ToGlibPtr<'a, *mut gobject_sys::GValue> for &'a [&'a ToValue] {
+impl<'a> ToGlibPtr<'a, *mut gobject_sys::GValue> for &'a [&'a dyn ToValue] {
     type Storage = ValueArray;
 
     fn to_glib_none(&'a self) -> Stash<'a, *mut gobject_sys::GValue, Self> {

src/value_array.rs

@@ -64,8 +64,8 @@ impl ValueArray {
     pub fn sort_with_data<F: FnMut(&Value, &Value) -> Ordering>(&mut self, compare_func: F) {
         unsafe {
             let mut func = compare_func;
-            let func_obj: &mut (FnMut(&Value, &Value) -> Ordering) = &mut func;
-            let func_ptr = &func_obj as *const &mut (FnMut(&Value, &Value) -> Ordering) as glib_sys::gpointer;
+            let func_obj: &mut (dyn FnMut(&Value, &Value) -> Ordering) = &mut func;
+            let func_ptr = &func_obj as *const &mut (dyn FnMut(&Value, &Value) -> Ordering) as glib_sys::gpointer;
 
             gobject_sys::g_value_array_sort_with_data(self.to_glib_none_mut().0, Some(compare_func_trampoline), func_ptr);
         }
@@ -92,7 +92,7 @@ impl ops::DerefMut for ValueArray {
 
 unsafe extern "C" fn compare_func_trampoline(a: glib_sys::gconstpointer, b: glib_sys::gconstpointer, func: glib_sys::gpointer) -> i32
 {
-    let func = func as *mut &mut (FnMut(&Value, &Value) -> Ordering);
+    let func = func as *mut &mut (dyn FnMut(&Value, &Value) -> Ordering);
 
     let a = &*(a as *const Value);
     let b = &*(b as *const Value);