Fix clippy lints

Author: GuillaumeGomez

cairo/src/paths.rs

@@ -102,7 +102,7 @@ impl<'a> Iterator for PathSegments<'a> {
                     to_tuple(&self.data[self.i + 3].point),
                 ),
                 PathDataType::ClosePath => PathSegment::ClosePath,
-                PathDataType::__Unknown(x) => panic!("Unknown value: {}", x),
+                PathDataType::__Unknown(x) => panic!("Unknown value: {x}"),
             };
 
             self.i += self.data[self.i].header.length as usize;

cairo/sys/build.rs

@@ -7,7 +7,7 @@ fn main() {} // prevent linking libraries to avoid documentation failure
 #[cfg(not(feature = "dox"))]
 fn main() {
     if let Err(s) = system_deps::Config::new().probe() {
-        println!("cargo:warning={}", s);
+        println!("cargo:warning={s}");
         process::exit(1);
     }
 }

examples/gio_cancellable_future/main.rs

@@ -27,7 +27,7 @@ fn main() {
         let cancellable_task = gio::CancellableFuture::new(a_very_long_task(), cancellable.clone())
             .map(move |res| {
                 if let Err(error) = res {
-                    println!("{:?}", error);
+                    println!("{error:?}");
                 }
 
                 main_loop.quit();

examples/gio_futures/main.rs

@@ -17,7 +17,7 @@ fn main() {
             // error first print that error.
             .map(move |res| {
                 if let Err(err) = res {
-                    eprintln!("Got error: {}", err);
+                    eprintln!("Got error: {err}");
                 }
 
                 l_clone.quit();
@@ -36,7 +36,7 @@ fn read_and_print_file(
     file: &gio::File,
 ) -> impl Future<Output = Result<(), String>> + std::marker::Unpin {
     file.read_future(glib::PRIORITY_DEFAULT)
-        .map_err(|err| format!("Failed to open file: {}", err))
+        .map_err(|err| format!("Failed to open file: {err}"))
         .and_then(read_and_print_chunks)
 }
 
@@ -98,9 +98,9 @@ fn read_and_print_next_chunk(
 ) -> impl Future<Output = Result<Option<Vec<u8>>, String>> + std::marker::Unpin {
     let strm_clone = strm.clone();
     strm.read_future(buf, glib::PRIORITY_DEFAULT)
-        .map_err(|(_buf, err)| format!("Failed to read from stream: {}", err))
+        .map_err(|(_buf, err)| format!("Failed to read from stream: {err}"))
         .and_then(move |(buf, len)| {
-            println!("line {}: {:?}", idx, str::from_utf8(&buf[0..len]).unwrap());
+            println!("line {idx}: {:?}", str::from_utf8(&buf[0..len]).unwrap());
 
             // 0 is only returned when the input stream is finished, in which case
             // we drop the buffer and close the stream asynchronously.
@@ -111,7 +111,7 @@ fn read_and_print_next_chunk(
                 futures::future::Either::Left(
                     strm_clone
                         .close_future(glib::PRIORITY_DEFAULT)
-                        .map_err(|err| format!("Failed to close stream: {}", err))
+                        .map_err(|err| format!("Failed to close stream: {err}"))
                         .map_ok(|_| None),
                 )
             } else {

examples/gio_futures_await/main.rs

@@ -14,7 +14,7 @@ fn main() {
     let future = clone!(@strong l => async move {
         match read_file(file).await {
             Ok(()) => (),
-            Err(err) => eprintln!("Got error: {}", err),
+            Err(err) => eprintln!("Got error: {err}"),
         }
         l.quit();
     });
@@ -30,7 +30,7 @@ async fn read_file(file: gio::File) -> Result<(), String> {
     // Try to open the file.
     let strm = file
         .read_future(glib::PRIORITY_DEFAULT)
-        .map_err(|err| format!("Failed to open file: {}", err))
+        .map_err(|err| format!("Failed to open file: {err}"))
         .await?;
 
     // If opening the file succeeds, we asynchronously loop and
@@ -42,7 +42,7 @@ async fn read_file(file: gio::File) -> Result<(), String> {
     loop {
         let (b, len) = strm
             .read_future(buf, glib::PRIORITY_DEFAULT)
-            .map_err(|(_buf, err)| format!("Failed to read from stream: {}", err))
+            .map_err(|(_buf, err)| format!("Failed to read from stream: {err}"))
             .await?;
 
         // Once 0 is returned, we know that we're done with reading, otherwise
@@ -53,14 +53,14 @@ async fn read_file(file: gio::File) -> Result<(), String> {
 
         buf = b;
 
-        println!("line {}: {:?}", idx, str::from_utf8(&buf[0..len]).unwrap());
+        println!("line {idx}: {:?}", str::from_utf8(&buf[0..len]).unwrap());
 
         idx += 1;
     }
 
     // Asynchronously close the stream in the end.
     strm.close_future(glib::PRIORITY_DEFAULT)
-        .map_err(|err| format!("Failed to close stream: {}", err))
+        .map_err(|err| format!("Failed to close stream: {err}"))
         .await?;
 
     Ok(())

examples/gio_task/main.rs

@@ -58,7 +58,7 @@ fn run_unsafe(send: oneshot::Sender<()>) {
             return;
         }
 
-        println!("Unsafe callback - Returned value from task: {}", ret);
+        println!("Unsafe callback - Returned value from task: {ret}");
         println!(
             "Unsafe callback - FileSize::size: {}",
             file_size::ffi::my_file_size_get_retrieved_size(
@@ -89,7 +89,7 @@ fn run_safe(send: oneshot::Sender<()>) {
     let cancellable = gio::Cancellable::new();
 
     let closure = move |value: i64, source_object: &FileSize| {
-        println!("Safe callback - Returned value from task: {}", value);
+        println!("Safe callback - Returned value from task: {value}");
         println!(
             "Safe callback - FileSize::size: {}",
             source_object.retrieved_size().unwrap()

gdk-pixbuf/src/auto/versions.txt

@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ f0e953c094a5)
+Generated by gir (https://github.com/gtk-rs/gir @ 818f714dc796)
 from gir-files (https://github.com/gtk-rs/gir-files @ 89a11aa6a362)

gdk-pixbuf/src/pixbuf.rs

@@ -50,7 +50,7 @@ impl Pixbuf {
         let ptr = {
             let data: &mut [u8] = (*data).as_mut();
             assert!(
-                data.len() >= ((height - 1) * row_stride + last_row_len) as usize,
+                data.len() >= ((height - 1) * row_stride + last_row_len),
                 "data.len() must fit the width, height, and row_stride"
             );
             data.as_mut_ptr()
@@ -406,7 +406,7 @@ impl Pixbuf {
             if error.is_null() {
                 Ok(FromGlibContainer::from_glib_full_num(
                     buffer,
-                    buffer_size.assume_init() as usize,
+                    buffer_size.assume_init() as _,
                 ))
             } else {
                 Err(from_glib_full(error))

gdk-pixbuf/sys/build.rs

@@ -11,7 +11,7 @@ fn main() {} // prevent linking libraries to avoid documentation failure
 #[cfg(not(feature = "dox"))]
 fn main() {
     if let Err(s) = system_deps::Config::new().probe() {
-        println!("cargo:warning={}", s);
+        println!("cargo:warning={s}");
         process::exit(1);
     }
 }

gdk-pixbuf/sys/src/lib.rs

@@ -127,7 +127,7 @@ pub struct GdkPixbufAnimationClass {
 
 impl ::std::fmt::Debug for GdkPixbufAnimationClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufAnimationClass @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufAnimationClass @ {self:p}"))
             .field("parent_class", &self.parent_class)
             .field("is_static_image", &self.is_static_image)
             .field("get_static_image", &self.get_static_image)
@@ -152,7 +152,7 @@ pub struct GdkPixbufAnimationIterClass {
 
 impl ::std::fmt::Debug for GdkPixbufAnimationIterClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufAnimationIterClass @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufAnimationIterClass @ {self:p}"))
             .field("parent_class", &self.parent_class)
             .field("get_delay_time", &self.get_delay_time)
             .field("get_pixbuf", &self.get_pixbuf)
@@ -181,7 +181,7 @@ pub struct GdkPixbufFormat {
 
 impl ::std::fmt::Debug for GdkPixbufFormat {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufFormat @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufFormat @ {self:p}"))
             .field("name", &self.name)
             .field("signature", &self.signature)
             .field("domain", &self.domain)
@@ -208,7 +208,7 @@ pub struct GdkPixbufLoaderClass {
 
 impl ::std::fmt::Debug for GdkPixbufLoaderClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufLoaderClass @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufLoaderClass @ {self:p}"))
             .field("parent_class", &self.parent_class)
             .field("size_prepared", &self.size_prepared)
             .field("area_prepared", &self.area_prepared)
@@ -242,7 +242,7 @@ pub struct GdkPixbufModule {
 
 impl ::std::fmt::Debug for GdkPixbufModule {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufModule @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufModule @ {self:p}"))
             .field("module_name", &self.module_name)
             .field("module_path", &self.module_path)
             .field("module", &self.module)
@@ -274,7 +274,7 @@ pub struct GdkPixbufModulePattern {
 
 impl ::std::fmt::Debug for GdkPixbufModulePattern {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufModulePattern @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufModulePattern @ {self:p}"))
             .field("prefix", &self.prefix)
             .field("mask", &self.mask)
             .field("relevance", &self.relevance)
@@ -299,7 +299,7 @@ pub struct GdkPixbuf {
 
 impl ::std::fmt::Debug for GdkPixbuf {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbuf @ {:p}", self)).finish()
+        f.debug_struct(&format!("GdkPixbuf @ {self:p}")).finish()
     }
 }
 
@@ -311,7 +311,7 @@ pub struct GdkPixbufAnimation {
 
 impl ::std::fmt::Debug for GdkPixbufAnimation {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufAnimation @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufAnimation @ {self:p}"))
             .field("parent_instance", &self.parent_instance)
             .finish()
     }
@@ -325,7 +325,7 @@ pub struct GdkPixbufAnimationIter {
 
 impl ::std::fmt::Debug for GdkPixbufAnimationIter {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufAnimationIter @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufAnimationIter @ {self:p}"))
             .field("parent_instance", &self.parent_instance)
             .finish()
     }
@@ -340,7 +340,7 @@ pub struct GdkPixbufLoader {
 
 impl ::std::fmt::Debug for GdkPixbufLoader {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufLoader @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufLoader @ {self:p}"))
             .finish()
     }
 }
@@ -353,7 +353,7 @@ pub struct GdkPixbufNonAnim {
 
 impl ::std::fmt::Debug for GdkPixbufNonAnim {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufNonAnim @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufNonAnim @ {self:p}"))
             .finish()
     }
 }
@@ -366,7 +366,7 @@ pub struct GdkPixbufSimpleAnim {
 
 impl ::std::fmt::Debug for GdkPixbufSimpleAnim {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufSimpleAnim @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufSimpleAnim @ {self:p}"))
             .finish()
     }
 }
@@ -379,7 +379,7 @@ pub struct GdkPixbufSimpleAnimIter {
 
 impl ::std::fmt::Debug for GdkPixbufSimpleAnimIter {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("GdkPixbufSimpleAnimIter @ {:p}", self))
+        f.debug_struct(&format!("GdkPixbufSimpleAnimIter @ {self:p}"))
             .finish()
     }
 }