Fix clippy issues on stable

examples/child_window.rs

@@ -27,7 +27,7 @@ fn main() {
 
  let id = child_window.id();
  windows.insert(id, child_window);
- println!("child window created with id: {:?}", id);
+ println!("child window created with id: {id:?}");
  }
 
  let mut windows = HashMap::new();
@@ -40,7 +40,7 @@ fn main() {
  .build(&event_loop)
  .unwrap();
 
- println!("parent window: {:?})", parent_window);
+ println!("parent window: {parent_window:?})");
 
  event_loop.run(move |event: Event<'_, ()>, event_loop, control_flow| {
  *control_flow = ControlFlow::Wait;
@@ -56,7 +56,7 @@ fn main() {
  // by some key inputs.
  // the child windows are always placed at (0, 0) with size (200, 200) in the parent window,
  // so we also can see this log when we move the cursor arround (200, 200) in parent window.
- println!("cursor entered in the window {:?}", window_id);
+ println!("cursor entered in the window {window_id:?}");
  }
  WindowEvent::KeyboardInput {
  input:

examples/control_flow.rs

@@ -41,7 +41,7 @@ fn main() {
 
  event_loop.run(move |event, _, control_flow| {
  use winit::event::{ElementState, StartCause, VirtualKeyCode};
- println!("{:?}", event);
+ println!("{event:?}");
  match event {
  Event::NewEvents(start_cause) => {
  wait_cancelled = match start_cause {
@@ -64,19 +64,19 @@ fn main() {
  } => match virtual_code {
  VirtualKeyCode::Key1 => {
  mode = Mode::Wait;
- println!("\nmode: {:?}\n", mode);
+ println!("\nmode: {mode:?}\n");
  }
  VirtualKeyCode::Key2 => {
  mode = Mode::WaitUntil;
- println!("\nmode: {:?}\n", mode);
+ println!("\nmode: {mode:?}\n");
  }
  VirtualKeyCode::Key3 => {
  mode = Mode::Poll;
- println!("\nmode: {:?}\n", mode);
+ println!("\nmode: {mode:?}\n");
  }
  VirtualKeyCode::R => {
  request_redraw = !request_redraw;
- println!("\nrequest_redraw: {}\n", request_redraw);
+ println!("\nrequest_redraw: {request_redraw}\n");
  }
  VirtualKeyCode::Escape => {
  close_requested = true;

examples/cursor_grab.rs

@@ -50,17 +50,17 @@ fn main() {
  };
 
  if let Err(err) = result {
- println!("error: {}", err);
+ println!("error: {err}");
  }
  }
  WindowEvent::ModifiersChanged(m) => modifiers = m,
  _ => (),
  },
  Event::DeviceEvent { event, .. } => match event {
- DeviceEvent::MouseMotion { delta } => println!("mouse moved: {:?}", delta),
+ DeviceEvent::MouseMotion { delta } => println!("mouse moved: {delta:?}"),
  DeviceEvent::Button { button, state } => match state {
- ElementState::Pressed => println!("mouse button {} pressed", button),
- ElementState::Released => println!("mouse button {} released", button),
+ ElementState::Pressed => println!("mouse button {button} pressed"),
+ ElementState::Released => println!("mouse button {button} released"),
  },
  _ => (),
  },

examples/custom_events.rs

@@ -39,7 +39,7 @@ fn main() {
  control_flow.set_wait();
 
  match event {
- Event::UserEvent(event) => println!("user event: {:?}", event),
+ Event::UserEvent(event) => println!("user event: {event:?}"),
  Event::WindowEvent {
  event: WindowEvent::CloseRequested,
  ..

examples/fullscreen.rs

@@ -26,7 +26,7 @@ fn main() {
 
  let mut mode_index = 0;
  let mut mode = monitor.video_modes().next().expect("no mode found");
- println!("Mode: {}", mode);
+ println!("Mode: {mode}");
 
  println!("Keys:");
  println!("- Esc\tExit");
@@ -59,12 +59,12 @@ fn main() {
  }
  VirtualKeyCode::F => {
  let fullscreen = Some(Fullscreen::Exclusive(mode.clone()));
- println!("Setting mode: {:?}", fullscreen);
+ println!("Setting mode: {fullscreen:?}");
  window.set_fullscreen(fullscreen);
  }
  VirtualKeyCode::B => {
  let fullscreen = Some(Fullscreen::Borderless(Some(monitor.clone())));
- println!("Setting mode: {:?}", fullscreen);
+ println!("Setting mode: {fullscreen:?}");
  window.set_fullscreen(fullscreen);
  }
  VirtualKeyCode::S => {
@@ -79,7 +79,7 @@ fn main() {
 
  mode_index = 0;
  mode = monitor.video_modes().next().expect("no mode found");
- println!("Mode: {}", mode);
+ println!("Mode: {mode}");
  }
  VirtualKeyCode::M => {
  mode_index += 1;
@@ -89,7 +89,7 @@ fn main() {
  mode_index = 0;
  mode = monitor.video_modes().next().expect("no mode found");
  }
- println!("Mode: {}", mode);
+ println!("Mode: {mode}");
  }
  VirtualKeyCode::D => {
  decorations = !decorations;

examples/ime.rs

@@ -67,7 +67,7 @@ fn main() {
  event: WindowEvent::Ime(event),
  ..
  } => {
- println!("{:?}", event);
+ println!("{event:?}");
  may_show_ime = event != Ime::Disabled;
  if may_show_ime {
  window.set_ime_position(ime_pos);
@@ -77,20 +77,20 @@ fn main() {
  event: WindowEvent::ReceivedCharacter(ch),
  ..
  } => {
- println!("ch: {:?}", ch);
+ println!("ch: {ch:?}");
  }
  Event::WindowEvent {
  event: WindowEvent::KeyboardInput { input, .. },
  ..
  } => {
- println!("key: {:?}", input);
+ println!("key: {input:?}");
 
  if input.state == ElementState::Pressed
  && input.virtual_keycode == Some(VirtualKeyCode::F2)
  {
  ime_allowed = !ime_allowed;
  window.set_ime_allowed(ime_allowed);
- println!("\nIME: {}\n", ime_allowed);
+ println!("\nIME: {ime_allowed}\n");
  }
  }
  _ => (),

examples/mouse_wheel.rs

@@ -39,7 +39,7 @@ In other words, the deltas indicate the direction in which to move the content (
  WindowEvent::CloseRequested => control_flow.set_exit(),
  WindowEvent::MouseWheel { delta, .. } => match delta {
  winit::event::MouseScrollDelta::LineDelta(x, y) => {
- println!("mouse wheel Line Delta: ({},{})", x, y);
+ println!("mouse wheel Line Delta: ({x},{y})");
  let pixels_per_line = 120.0;
  let mut pos = window.outer_position().unwrap();
  pos.x += (x * pixels_per_line) as i32;

examples/multithreaded.rs

@@ -62,7 +62,7 @@ fn main() {
  },
  ..
  } => {
- window.set_title(&format!("{:?}", key));
+ window.set_title(&format!("{key:?}"));
  let state = !modifiers.shift();
  use VirtualKeyCode::*;
  match key {
@@ -92,17 +92,17 @@ fn main() {
  }),
  L if state => {
  if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked) {
- println!("error: {}", err);
+ println!("error: {err}");
  }
  }
  G if state => {
  if let Err(err) = window.set_cursor_grab(CursorGrabMode::Confined) {
- println!("error: {}", err);
+ println!("error: {err}");
  }
  }
  G | L if !state => {
  if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
- println!("error: {}", err);
+ println!("error: {err}");
  }
  }
  H => window.set_cursor_visible(!state),

examples/multiwindow.rs

@@ -29,7 +29,7 @@ fn main() {
  Event::WindowEvent { event, window_id } => {
  match event {
  WindowEvent::CloseRequested => {
- println!("Window {:?} has received the signal to close", window_id);
+ println!("Window {window_id:?} has received the signal to close");
 
  // This drops the window, causing it to close.
  windows.remove(&window_id);

examples/request_redraw.rs

@@ -17,7 +17,7 @@ fn main() {
  .unwrap();
 
  event_loop.run(move |event, _, control_flow| {
- println!("{:?}", event);
+ println!("{event:?}");
 
  control_flow.set_wait();
 

examples/request_redraw_threaded.rs

@@ -25,7 +25,7 @@ fn main() {
  });
 
  event_loop.run(move |event, _, control_flow| {
- println!("{:?}", event);
+ println!("{event:?}");
 
  control_flow.set_wait();
 

examples/resizable.rs

@@ -39,7 +39,7 @@ fn main() {
  ..
  } => {
  resizable = !resizable;
- println!("Resizable: {}", resizable);
+ println!("Resizable: {resizable}");
  window.set_resizable(resizable);
  }
  _ => (),

examples/theme.rs

@@ -36,7 +36,7 @@ fn main() {
  window_id,
  ..
  } if window_id == window.id() => {
- println!("Theme is changed: {:?}", theme)
+ println!("Theme is changed: {theme:?}")
  }
  Event::WindowEvent {
  event:

examples/timer.rs

@@ -22,7 +22,7 @@ fn main() {
  let timer_length = Duration::new(1, 0);
 
  event_loop.run(move |event, _, control_flow| {
- println!("{:?}", event);
+ println!("{event:?}");
 
  match event {
  Event::NewEvents(StartCause::Init) => {

examples/touchpad_gestures.rs

@@ -24,19 +24,19 @@ fn main() {
  WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
  WindowEvent::TouchpadMagnify { delta, .. } => {
  if delta > 0.0 {
- println!("Zoomed in {}", delta);
+ println!("Zoomed in {delta}");
  } else {
- println!("Zoomed out {}", delta);
+ println!("Zoomed out {delta}");
  }
  }
  WindowEvent::SmartMagnify { .. } => {
  println!("Smart zoom");
  }
  WindowEvent::TouchpadRotate { delta, .. } => {
  if delta > 0.0 {
- println!("Rotated counterclockwise {}", delta);
+ println!("Rotated counterclockwise {delta}");
  } else {
- println!("Rotated clockwise {}", delta);
+ println!("Rotated clockwise {delta}");
  }
  }
  _ => (),

examples/transparent.rs

@@ -21,7 +21,7 @@ fn main() {
 
  event_loop.run(move |event, _, control_flow| {
  control_flow.set_wait();
- println!("{:?}", event);
+ println!("{event:?}");
 
  match event {
  Event::WindowEvent {

examples/video_modes.rs

@@ -17,6 +17,6 @@ fn main() {
  println!("Listing available video modes:");
 
  for mode in monitor.video_modes() {
- println!("{}", mode);
+ println!("{mode}");
  }
 }

examples/web.rs

@@ -81,7 +81,7 @@ mod wasm {
  let window = web_sys::window().unwrap();
  let document = window.document().unwrap();
  let log = document.create_element("li").unwrap();
- log.set_text_content(Some(&format!("{:?}", event)));
+ log.set_text_content(Some(&format!("{event:?}")));
  log_list
  .insert_before(&log, log_list.first_child().as_ref())
  .unwrap();

examples/window.rs

@@ -19,7 +19,7 @@ fn main() {
 
  event_loop.run(move |event, _, control_flow| {
  control_flow.set_wait();
- println!("{:?}", event);
+ println!("{event:?}");
 
  match event {
  Event::WindowEvent {

examples/window_run_return.rs

@@ -35,7 +35,7 @@ fn main() {
 
  if let Event::WindowEvent { event, .. } = &event {
  // Print only Window events to reduce noise
- println!("{:?}", event);
+ println!("{event:?}");
  }
 
  match event {

src/icon.rs

@@ -34,19 +34,17 @@ impl fmt::Display for BadIcon {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  match self {
  BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
- "The length of the `rgba` argument ({:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
- byte_count,
+ "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
  ),
  BadIcon::DimensionsVsPixelCount {
  width,
  height,
  width_x_height,
  pixel_count,
  } => write!(f,
- "The specified dimensions ({:?}x{:?}) don't match the number of pixels supplied by the `rgba` argument ({:?}). For those dimensions, the expected pixel count is {:?}.",
- width, height, pixel_count, width_x_height,
+ "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
  ),
- BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {:?}", e),
+ BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {e:?}"),
  }
  }
 }

src/platform_impl/android/mod.rs

@@ -349,10 +349,10 @@ impl<T: 'static> EventLoop<T> {
  }
  }
 
- fn single_iteration<'a, F>(
+ fn single_iteration<F>(
  &mut self,
  control_flow: &mut ControlFlow,
- main_event: Option<MainEvent<'a>>,
+ main_event: Option<MainEvent<'_>>,
  pending_redraw: &mut bool,
  cause: &mut StartCause,
  callback: &mut F,

src/platform_impl/linux/mod.rs

@@ -727,8 +727,7 @@ impl<T: 'static> EventLoop<T> {
  panic!("wayland feature is not enabled");
  }
  _ => panic!(
- "Unknown environment variable value for {}, try one of `x11`,`wayland`",
- BACKEND_PREFERENCE_ENV_VAR,
+ "Unknown environment variable value for {BACKEND_PREFERENCE_ENV_VAR}, try one of `x11`,`wayland`",
  ),
  }
  }
@@ -751,8 +750,7 @@ impl<T: 'static> EventLoop<T> {
  let x11_err = "backend disabled";
 
  panic!(
- "Failed to initialize any backend! Wayland status: {:?} X11 status: {:?}",
- wayland_err, x11_err,
+ "Failed to initialize any backend! Wayland status: {wayland_err:?} X11 status: {x11_err:?}",
  );
  }