Merge pull request #100 from yzhs/clippy-warnings

Address some more clippy warnings

anvil/src/input_handler.rs

@@ -303,12 +303,11 @@ enum KeyAction {
 }
 
 fn process_keyboard_shortcut(modifiers: &ModifiersState, keysym: Keysym) -> KeyAction {
-    if modifiers.ctrl && modifiers.alt && keysym == xkb::KEY_BackSpace {
+    if modifiers.ctrl && modifiers.alt && keysym == xkb::KEY_BackSpace
-        // ctrl+alt+backspace = quit
+        || modifiers.logo && keysym == xkb::KEY_q {
-        KeyAction::Quit
+            // ctrl+alt+backspace = quit
-    } else if modifiers.logo && keysym == xkb::KEY_q {
+            // logo + q = quit
-        // logo + q = quit
+            KeyAction::Quit
-        KeyAction::Quit
     } else if keysym >= xkb::KEY_XF86Switch_VT_1 && keysym <= xkb::KEY_XF86Switch_VT_12 {
         // VTSwicth
         KeyAction::VtSwitch((keysym - xkb::KEY_XF86Switch_VT_1 + 1) as i32)

anvil/src/main.rs

@@ -44,7 +44,7 @@ fn main() {
 
     let (mut display, mut event_loop) = Display::new();
 
-    let arg = ::std::env::args().skip(1).next();
+    let arg = ::std::env::args().nth(1);
     match arg.as_ref().map(|s| &s[..]) {
         #[cfg(feature = "winit")]
         Some("--winit") => {
@@ -69,7 +69,7 @@ fn main() {
         }
         _ => {
             println!("USAGE: anvil --backend");
-            println!("");
+            println!();
             println!("Possible backends are:");
             for b in POSSIBLE_BACKENDS {
                 println!("\t{}", b);

anvil/src/shaders.rs

@@ -36,7 +36,7 @@ macro_rules! opengl_programs(
  * OpenGL Shaders
  */
 
-pub const VERTEX_SHADER: &'static str = r#"
+pub const VERTEX_SHADER: &str = r#"
 #version 100
 uniform lowp mat4 matrix;
 attribute lowp vec2 position;
@@ -50,7 +50,7 @@ void main() {
 pub const FRAGMENT_COUNT: usize = 5;
 
 pub const BUFFER_RGBA: usize = 0;
-pub const FRAGMENT_SHADER_RGBA: &'static str = r#"
+pub const FRAGMENT_SHADER_RGBA: &str = r#"
 #version 100
 uniform lowp sampler2D tex;
 varying lowp vec2 v_tex_coords;
@@ -64,7 +64,7 @@ void main() {
 "#;
 
 pub const BUFFER_ABGR: usize = 1;
-pub const FRAGMENT_SHADER_ABGR: &'static str = r#"
+pub const FRAGMENT_SHADER_ABGR: &str = r#"
 #version 100
 uniform lowp sampler2D tex;
 varying lowp vec2 v_tex_coords;
@@ -78,7 +78,7 @@ void main() {
 "#;
 
 pub const BUFFER_XBGR: usize = 2;
-pub const FRAGMENT_SHADER_XBGR: &'static str = r#"
+pub const FRAGMENT_SHADER_XBGR: &str = r#"
 #version 100
 uniform lowp sampler2D tex;
 varying lowp vec2 v_tex_coords;
@@ -92,7 +92,7 @@ void main() {
 "#;
 
 pub const BUFFER_BGRA: usize = 3;
-pub const FRAGMENT_SHADER_BGRA: &'static str = r#"
+pub const FRAGMENT_SHADER_BGRA: &str = r#"
 #version 100
 uniform lowp sampler2D tex;
 varying lowp vec2 v_tex_coords;
@@ -106,7 +106,7 @@ void main() {
 "#;
 
 pub const BUFFER_BGRX: usize = 4;
-pub const FRAGMENT_SHADER_BGRX: &'static str = r#"
+pub const FRAGMENT_SHADER_BGRX: &str = r#"
 #version 100
 uniform lowp sampler2D tex;
 varying lowp vec2 v_tex_coords;

anvil/src/shell.rs

@@ -55,7 +55,7 @@ pub fn init_shell(
     let (xdg_shell_state, _, _) = xdg_shell_init(
         display,
         looptoken.clone(),
-        compositor_token.clone(),
+        compositor_token,
         move |shell_event, ()| match shell_event {
             XdgRequest::NewToplevel { surface } => {
                 // place the window at a random location in the [0;300]x[0;300] square
@@ -88,12 +88,12 @@ pub fn init_shell(
     let (wl_shell_state, _) = wl_shell_init(
         display,
         looptoken,
-        compositor_token.clone(),
+        compositor_token,
-        move |req: ShellRequest<_, _, ()>, ()| match req {
+        move |req: ShellRequest<_, _, ()>, ()|
-            ShellRequest::SetKind {
+            if let ShellRequest::SetKind {
                 surface,
                 kind: ShellSurfaceKind::Toplevel,
-            } => {
+            } = req {
                 // place the window at a random location in the [0;300]x[0;300] square
                 use rand::distributions::{IndependentSample, Range};
                 let range = Range::new(0, 300);
@@ -104,9 +104,7 @@ pub fn init_shell(
                 shell_window_map
                     .borrow_mut()
                     .insert(SurfaceKind::Wl(surface), (x, y));
-            }
+            },
-            _ => (),
-        },
         log.clone(),
     );
 

anvil/src/shm_load.rs

@@ -5,7 +5,7 @@ use smithay::wayland_server::protocol::wl_shm::Format;
 
 use glium::texture::{ClientFormat, RawImage2d};
 
-pub fn load_shm_buffer<'a>(data: BufferData, pool: &'a [u8]) -> Result<(RawImage2d<'a, u8>, usize), Format> {
+pub fn load_shm_buffer(data: BufferData, pool: &[u8]) -> Result<(RawImage2d<u8>, usize), Format> {
     let offset = data.offset as usize;
     let width = data.width as usize;
     let height = data.height as usize;

anvil/src/udev.rs

@@ -105,7 +105,7 @@ pub fn run_udev(mut display: Display, mut event_loop: EventLoop, log: Logger) ->
     let (mut w_seat, _) = Seat::new(
         &mut display.borrow_mut(),
         event_loop.token(),
-        session.seat().into(),
+        session.seat(),
         log.clone(),
     );
 
@@ -174,7 +174,7 @@ pub fn run_udev(mut display: Display, mut event_loop: EventLoop, log: Logger) ->
         .unwrap();
 
     while running.load(Ordering::SeqCst) {
-        if let Err(_) = event_loop.dispatch(Some(16)) {
+        if event_loop.dispatch(Some(16)).is_err() {
             running.store(false, Ordering::SeqCst);
         } else {
             display.borrow_mut().flush_clients();
@@ -288,7 +288,7 @@ impl UdevHandler<DrmHandlerImpl> for UdevHandlerImpl {
         self.backends.insert(device.device_id(), backends.clone());
 
         Some(DrmHandlerImpl {
-            compositor_token: self.compositor_token.clone(),
+            compositor_token: self.compositor_token,
             backends,
             window_map: self.window_map.clone(),
             pointer_location: self.pointer_location.clone(),
@@ -298,7 +298,7 @@ impl UdevHandler<DrmHandlerImpl> for UdevHandlerImpl {
 
     fn device_changed(&mut self, device: &mut DrmDevice<SessionFdDrmDevice>) {
         //quick and dirt, just re-init all backends
-        let backends = self.backends.get(&device.device_id()).unwrap();
+        let backends = &self.backends[&device.device_id()];
         *backends.borrow_mut() = self.scan_connectors(device, self.active_egl_context.clone());
     }
 

anvil/src/window_map.rs

@@ -155,22 +155,22 @@ where
 {
     pub fn new(ctoken: CompositorToken<U, R>, get_size: F) -> WindowMap<U, R, D, SD, F> {
         WindowMap {
-            ctoken: ctoken,
+            ctoken,
             windows: Vec::new(),
-            get_size: get_size,
+            get_size,
         }
     }
 
     pub fn insert(&mut self, toplevel: Kind<U, R, SD, D>, location: (i32, i32)) {
         let mut window = Window {
-            location: location,
+            location,
             surface: Rectangle {
                 x: 0,
                 y: 0,
                 width: 0,
                 height: 0,
             },
-            toplevel: toplevel,
+            toplevel,
         };
         window.self_update(self.ctoken, &self.get_size);
         self.windows.insert(0, window);
@@ -219,7 +219,7 @@ where
 
     pub fn refresh(&mut self) {
         self.windows.retain(|w| w.toplevel.alive());
-        for w in self.windows.iter_mut() {
+        for w in &mut self.windows {
             w.self_update(self.ctoken, &self.get_size);
         }
     }

src/backend/drm/backend.rs

@@ -171,11 +171,11 @@ impl<A: Device + 'static> DrmBackend<A> {
             if !encoders
                 .iter()
                 .map(|encoder| encoder.possible_crtcs())
-                .all(|crtc_list| {
+                .all(|crtc_list|
                     resource_handles
                         .filter_crtcs(crtc_list)
                         .contains(&self.backend.crtc)
-                }) {
+                ) {
                 bail!(ErrorKind::NoSuitableEncoder(info, self.backend.crtc));
             }
 
@@ -473,12 +473,13 @@ impl<A: Device + 'static> GraphicsBackend for DrmBackend<A> {
 
 impl<A: Device + 'static> EGLGraphicsBackend for DrmBackend<A> {
     fn swap_buffers(&self) -> ::std::result::Result<(), SwapBuffersError> {
-        if {
+        let res = {
             let nb = self.backend.next_buffer.take();
             let res = nb.is_some();
             self.backend.next_buffer.set(nb);
             res
-        } {
+        };
+        if res {
             // We cannot call lock_front_buffer anymore without releasing the previous buffer, which will happen when the page flip is done
             warn!(
                 self.backend.logger,

src/backend/drm/mod.rs

@@ -328,7 +328,7 @@ impl<A: ControlDevice + 'static> DrmDevice<A> {
         info!(log, "DrmDevice initializing");
 
         // we want to mode-set, so we better be the master, if we run via a tty session
-        if let Err(_) = drm.set_master() {
+        if drm.set_master().is_err() {
             warn!(
                 log,
                 "Unable to become drm master, assuming unpriviledged mode"
@@ -594,7 +594,7 @@ where
     fn receive(&mut self, event: FdEvent, (): ()) {
         let mut device = self.device.borrow_mut();
         match event {
-            FdEvent::Ready { .. } => match crtc::receive_events(&mut *device) {
+            FdEvent::Ready { .. } => match crtc::receive_events(&*device) {
                 Ok(events) => for event in events {
                     if let crtc::Event::PageFlip(event) = event {
                         if device.active.load(Ordering::SeqCst) {
@@ -643,7 +643,7 @@ impl<A: ControlDevice + 'static> AsSessionObserver<DrmDeviceObserver<A>> for Drm
     fn observer(&mut self) -> DrmDeviceObserver<A> {
         DrmDeviceObserver {
             context: Rc::downgrade(&self.context),
-            device_id: self.device_id.clone(),
+            device_id: self.device_id,
             backends: self.backends.clone(),
             old_state: self.old_state.clone(),
             active: self.active.clone(),
@@ -662,7 +662,7 @@ impl<A: ControlDevice + 'static> SessionObserver for DrmDeviceObserver<A> {
             }
         }
         if let Some(device) = self.context.upgrade() {
-            for (handle, &(ref info, ref connectors)) in self.old_state.iter() {
+            for (handle, &(ref info, ref connectors)) in &self.old_state {
                 if let Err(err) = crtc::set(
                     &*device,
                     *handle,

src/backend/graphics/egl/native.rs

@@ -179,7 +179,7 @@ unsafe impl NativeDisplay<X11> for WinitWindow {
 
     fn create_surface(&self, _args: ()) -> Result<XlibWindow> {
         self.get_xlib_window()
-            .map(|ptr| XlibWindow(ptr))
+            .map(XlibWindow)
             .ok_or(ErrorKind::NonMatchingBackend("X11").into())
     }
 }

src/backend/input.rs

@@ -24,9 +24,9 @@ pub struct Seat {
 impl Seat {
     pub(crate) fn new<S: ToString>(id: u64, name: S, capabilities: SeatCapabilities) -> Seat {
         Seat {
-            id: id,
+            id,
             name: name.to_string(),
-            capabilities: capabilities,
+            capabilities,
         }
     }
 
@@ -331,7 +331,7 @@ pub struct TouchSlot {
 
 impl TouchSlot {
     pub(crate) fn new(id: u64) -> Self {
-        TouchSlot { id: id }
+        TouchSlot { id }
     }
 }
 

src/backend/libinput.rs

@@ -43,7 +43,7 @@ impl LibinputInputBackend {
         let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_libinput"));
         info!(log, "Initializing a libinput backend");
         LibinputInputBackend {
-            context: context,
+            context,
             devices: Vec::new(),
             seats: HashMap::new(),
             handler: None,
@@ -404,7 +404,7 @@ impl backend::InputBackend for LibinputInputBackend {
                     use input::event::touch::*;
                     if let Some(ref mut handler) = self.handler {
                         let device_seat = touch_event.device().seat();
-                        if let &Some(ref seat) = &self.seats.get(&device_seat) {
+                        if let Some(ref seat) = self.seats.get(&device_seat) {
                             match touch_event {
                                 TouchEvent::Down(down_event) => {
                                     trace!(self.logger, "Calling on_touch_down with {:?}", down_event);
@@ -446,7 +446,7 @@ impl backend::InputBackend for LibinputInputBackend {
                     match keyboard_event {
                         KeyboardEvent::Key(key_event) => if let Some(ref mut handler) = self.handler {
                             let device_seat = key_event.device().seat();
-                            if let &Some(ref seat) = &self.seats.get(&device_seat) {
+                            if let Some(ref seat) = self.seats.get(&device_seat) {
                                 trace!(self.logger, "Calling on_keyboard_key with {:?}", key_event);
                                 handler.on_keyboard_key(seat, key_event);
                             } else {
@@ -460,7 +460,7 @@ impl backend::InputBackend for LibinputInputBackend {
                     use input::event::pointer::*;
                     if let Some(ref mut handler) = self.handler {
                         let device_seat = pointer_event.device().seat();
-                        if let &Some(ref seat) = &self.seats.get(&device_seat) {
+                        if let Some(ref seat) = self.seats.get(&device_seat) {
                             match pointer_event {
                                 PointerEvent::Motion(motion_event) => {
                                     trace!(

src/backend/session/auto.rs

@@ -170,40 +170,40 @@ impl Session for AutoSession {
     type Error = Error;
 
     fn open(&mut self, path: &Path, flags: OFlag) -> Result<RawFd> {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &mut AutoSession::Logind(ref mut logind) => logind.open(path, flags).map_err(|e| e.into()),
+            AutoSession::Logind(ref mut logind) => logind.open(path, flags).map_err(|e| e.into()),
-            &mut AutoSession::Direct(ref mut direct) => direct.open(path, flags).map_err(|e| e.into()),
+            AutoSession::Direct(ref mut direct) => direct.open(path, flags).map_err(|e| e.into()),
         }
     }
     fn close(&mut self, fd: RawFd) -> Result<()> {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &mut AutoSession::Logind(ref mut logind) => logind.close(fd).map_err(|e| e.into()),
+            AutoSession::Logind(ref mut logind) => logind.close(fd).map_err(|e| e.into()),
-            &mut AutoSession::Direct(ref mut direct) => direct.close(fd).map_err(|e| e.into()),
+            AutoSession::Direct(ref mut direct) => direct.close(fd).map_err(|e| e.into()),
         }
     }
 
     fn change_vt(&mut self, vt: i32) -> Result<()> {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &mut AutoSession::Logind(ref mut logind) => logind.change_vt(vt).map_err(|e| e.into()),
+            AutoSession::Logind(ref mut logind) => logind.change_vt(vt).map_err(|e| e.into()),
-            &mut AutoSession::Direct(ref mut direct) => direct.change_vt(vt).map_err(|e| e.into()),
+            AutoSession::Direct(ref mut direct) => direct.change_vt(vt).map_err(|e| e.into()),
         }
     }
 
     fn is_active(&self) -> bool {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &AutoSession::Logind(ref logind) => logind.is_active(),
+            AutoSession::Logind(ref logind) => logind.is_active(),
-            &AutoSession::Direct(ref direct) => direct.is_active(),
+            AutoSession::Direct(ref direct) => direct.is_active(),
         }
     }
     fn seat(&self) -> String {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &AutoSession::Logind(ref logind) => logind.seat(),
+            AutoSession::Logind(ref logind) => logind.seat(),
-            &AutoSession::Direct(ref direct) => direct.seat(),
+            AutoSession::Direct(ref direct) => direct.seat(),
         }
     }
 }
@@ -215,12 +215,12 @@ impl SessionNotifier for AutoSessionNotifier {
         &mut self,
         signal: &mut A,
     ) -> Self::Id {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &mut AutoSessionNotifier::Logind(ref mut logind) => {
+            AutoSessionNotifier::Logind(ref mut logind) => {
                 AutoId(AutoIdInternal::Logind(logind.register(signal)))
             }
-            &mut AutoSessionNotifier::Direct(ref mut direct) => {
+            AutoSessionNotifier::Direct(ref mut direct) => {
                 AutoId(AutoIdInternal::Direct(direct.register(signal)))
             }
         }
@@ -239,17 +239,17 @@ impl SessionNotifier for AutoSessionNotifier {
     }
 
     fn is_active(&self) -> bool {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &AutoSessionNotifier::Logind(ref logind) => logind.is_active(),
+            AutoSessionNotifier::Logind(ref logind) => logind.is_active(),
-            &AutoSessionNotifier::Direct(ref direct) => direct.is_active(),
+            AutoSessionNotifier::Direct(ref direct) => direct.is_active(),
         }
     }
     fn seat(&self) -> &str {
-        match self {
+        match *self {
             #[cfg(feature = "backend_session_logind")]
-            &AutoSessionNotifier::Logind(ref logind) => logind.seat(),
+            AutoSessionNotifier::Logind(ref logind) => logind.seat(),
-            &AutoSessionNotifier::Direct(ref direct) => direct.seat(),
+            AutoSessionNotifier::Direct(ref direct) => direct.seat(),
         }
     }
 }

src/backend/session/direct.rs

@@ -177,7 +177,7 @@ impl DirectSession {
                 fcntl::OFlag::O_RDWR | fcntl::OFlag::O_CLOEXEC,
                 Mode::empty(),
             ).chain_err(|| ErrorKind::FailedToOpenTTY(String::from(path.to_string_lossy())))
-        }).unwrap_or(dup(0 /*stdin*/).chain_err(|| ErrorKind::FailedToOpenTTY(String::from("<stdin>"))))?;
+        }).unwrap_or_else(|| dup(0 /*stdin*/).chain_err(|| ErrorKind::FailedToOpenTTY(String::from("<stdin>"))))?;
 
         let active = Arc::new(AtomicBool::new(true));
 
@@ -372,7 +372,7 @@ impl Implementation<(), SignalEvent> for DirectSessionNotifier {
         if self.is_active() {
             info!(self.logger, "Session shall become inactive.");
             for signal in &mut self.signals {
-                if let &mut Some(ref mut signal) = signal {
+                if let Some(ref mut signal) = *signal {
                     signal.pause(None);
                 }
             }
@@ -387,7 +387,7 @@ impl Implementation<(), SignalEvent> for DirectSessionNotifier {
                 tty::vt_rel_disp(self.tty, tty::VT_ACKACQ).expect("Unable to acquire tty lock");
             }
             for signal in &mut self.signals {
-                if let &mut Some(ref mut signal) = signal {
+                if let Some(ref mut signal) = *signal {
                     signal.activate(None);
                 }
             }

src/backend/udev.rs

@@ -69,7 +69,7 @@ impl<H: DrmHandler<SessionFdDrmDevice> + 'static, S: Session + 'static, T: UdevH
     /// `session` - A session used to open and close devices as they become available
     /// `handler` - User-provided handler to respond to any detected changes
     /// `logger`  - slog Logger to be used by the backend and its `DrmDevices`.
-    pub fn new<'a, L>(
+    pub fn new<L>(
         token: LoopToken,
         context: &Context,
         mut session: S,
@@ -195,7 +195,7 @@ impl<
 }
 
 impl SessionObserver for UdevBackendObserver {
-    fn pause<'a>(&mut self, devnum: Option<(u32, u32)>) {
+    fn pause(&mut self, devnum: Option<(u32, u32)>) {
         if let Some(devices) = self.devices.upgrade() {
             for &mut (_, ref device) in devices.borrow_mut().values_mut() {
                 info!(self.logger, "changed successful");
@@ -204,7 +204,7 @@ impl SessionObserver for UdevBackendObserver {
         }
     }
 
-    fn activate<'a>(&mut self, devnum: Option<(u32, u32, Option<RawFd>)>) {
+    fn activate(&mut self, devnum: Option<(u32, u32, Option<RawFd>)>) {
         if let Some(devices) = self.devices.upgrade() {
             for &mut (_, ref device) in devices.borrow_mut().values_mut() {
                 info!(self.logger, "changed successful");

src/backend/winit.rs

@@ -53,9 +53,9 @@ enum Window {
 
 impl Window {
     fn window(&self) -> &WinitWindow {
-        match self {
+        match *self {
-            &Window::Wayland { ref context, .. } => &**context,
+            Window::Wayland { ref context, .. } => &**context,
-            &Window::X11 { ref context, .. } => &**context,
+            Window::X11 { ref context, .. } => &**context,
         }
     }
 }
@@ -697,12 +697,9 @@ impl InputBackend for WinitInputBackend {
                         (WindowEvent::Resized(w, h), _, events_handler) => {
                             trace!(logger, "Resizing window to {:?}", (w, h));
                             window.window().set_inner_size(w, h);
-                            match **window {
+                            if let Window::Wayland { ref surface, .. } = **window {
-                                Window::Wayland { ref surface, .. } => {
+                                surface.resize(w as i32, h as i32, 0, 0);
-                                    surface.resize(w as i32, h as i32, 0, 0)
+                            }
-                                }
-                                _ => {}
-                            };
                             if let Some(events_handler) = events_handler {
                                 events_handler.resized(w, h);
                             }
@@ -743,7 +740,7 @@ impl InputBackend for WinitInputBackend {
                                     time,
                                     key: scancode,
                                     count: *key_counter,
-                                    state: state,
+                                    state,
                                 },
                             )
                         }
@@ -760,8 +757,8 @@ impl InputBackend for WinitInputBackend {
                                 WinitMouseMovedEvent {
                                     window: window.clone(),
                                     time,
-                                    x: x,
+                                    x,
-                                    y: y,
+                                    y,
                                 },
                             )
                         }
@@ -780,8 +777,8 @@ impl InputBackend for WinitInputBackend {
                                 seat,
                                 WinitMouseInputEvent {
                                     time,
-                                    button: button,
+                                    button,
-                                    state: state,
+                                    state,
                                 },
                             )
                         }
@@ -802,7 +799,7 @@ impl InputBackend for WinitInputBackend {
                                     window: window.clone(),
                                     time,
                                     location: (x, y),
-                                    id: id,
+                                    id,
                                 },
                             )
                         }
@@ -823,7 +820,7 @@ impl InputBackend for WinitInputBackend {
                                     window: window.clone(),
                                     time,
                                     location: (x, y),
-                                    id: id,
+                                    id,
                                 },
                             )
                         }
@@ -844,11 +841,11 @@ impl InputBackend for WinitInputBackend {
                                     window: window.clone(),
                                     time,
                                     location: (x, y),
-                                    id: id,
+                                    id,
                                 },
                             );
                             trace!(logger, "Calling on_touch_up");
-                            handler.on_touch_up(seat, WinitTouchEndedEvent { time, id: id });
+                            handler.on_touch_up(seat, WinitTouchEndedEvent { time, id });
                         }
                         (
                             WindowEvent::Touch(Touch {
@@ -860,7 +857,7 @@ impl InputBackend for WinitInputBackend {
                             _,
                         ) => {
                             trace!(logger, "Calling on_touch_cancel");
-                            handler.on_touch_cancel(seat, WinitTouchCancelledEvent { time, id: id })
+                            handler.on_touch_cancel(seat, WinitTouchCancelledEvent { time, id })
                         }
                         (WindowEvent::CloseRequested, _, _) | (WindowEvent::Destroyed, _, _) => {
                             warn!(logger, "Window closed");

src/wayland/compositor/handlers.rs

@@ -57,8 +57,8 @@ impl<U, R> SurfaceImplem<U, R> {
             + 'static,
     {
         SurfaceImplem {
-            log: log,
+            log,
-            implem: implem,
+            implem,
         }
     }
 }

src/wayland/compositor/tree.rs

@@ -229,14 +229,14 @@ impl<U: 'static, R: RoleType + Role<SubsurfaceRole> + 'static> SurfaceData<U, R>
     pub unsafe fn get_parent(child: &Resource<WlSurface>) -> Option<Resource<WlSurface>> {
         let child_mutex = Self::get_data(child);
         let child_guard = child_mutex.lock().unwrap();
-        child_guard.parent.as_ref().map(|p| p.clone())
+        child_guard.parent.as_ref().cloned()
     }
 
     /// Retrieve the parent surface (if any) of this surface
     pub unsafe fn get_children(child: &Resource<WlSurface>) -> Vec<Resource<WlSurface>> {
         let child_mutex = Self::get_data(child);
         let child_guard = child_mutex.lock().unwrap();
-        child_guard.children.iter().map(|p| p.clone()).collect()
+        child_guard.children.to_vec()
     }
 
     /// Reorders a surface relative to one of its sibling
@@ -250,7 +250,7 @@ impl<U: 'static, R: RoleType + Role<SubsurfaceRole> + 'static> SurfaceData<U, R>
         let parent = {
             let data_mutex = Self::get_data(surface);
             let data_guard = data_mutex.lock().unwrap();
-            data_guard.parent.as_ref().map(|p| p.clone()).unwrap()
+            data_guard.parent.as_ref().cloned().unwrap()
         };
         if parent.equals(relative_to) {
             // TODO: handle positioning relative to parent

src/wayland/output/mod.rs

@@ -127,7 +127,7 @@ impl Inner {
                 flags |= WMode::Preferred;
             }
             output.send(Event::Mode {
-                flags: flags,
+                flags,
                 width: mode.width,
                 height: mode.height,
                 refresh: mode.refresh,
@@ -198,10 +198,10 @@ impl Output {
         info!(log, "Creating new wl_output"; "name" => &name);
 
         let inner = Arc::new(Mutex::new(Inner {
-            name: name,
+            name,
-            log: log,
+            log,
             instances: Vec::new(),
-            physical: physical,
+            physical,
             location: (0, 0),
             transform: Transform::Normal,
             scale: 1,
@@ -306,7 +306,7 @@ impl Output {
         for output in &inner.instances {
             if let Some(mode) = new_mode {
                 output.send(Event::Mode {
-                    flags: flags,
+                    flags,
                     width: mode.width,
                     height: mode.height,
                     refresh: mode.refresh,

src/wayland/seat/keyboard.rs

@@ -102,10 +102,10 @@ impl KbdInternal {
             focus: None,
             pressed_keys: Vec::new(),
             mods_state: ModifiersState::new(),
-            keymap: keymap,
+            keymap,
-            state: state,
+            state,
-            repeat_rate: repeat_rate,
+            repeat_rate,
-            repeat_delay: repeat_delay,
+            repeat_delay,
         })
     }
 
@@ -224,7 +224,7 @@ pub(crate) fn create_keyboard_handler(
     Ok(KeyboardHandle {
         arc: Arc::new(KbdArc {
             internal: Mutex::new(internal),
-            keymap_file: keymap_file,
+            keymap_file,
             keymap_len: keymap_data.as_bytes().len() as u32,
             logger: log,
         }),
@@ -349,7 +349,7 @@ impl KeyboardHandle {
             });
 
             // set new focus
-            guard.focus = focus.map(|s| s.clone());
+            guard.focus = focus.cloned();
             let (dep, la, lo, gr) = guard.serialize_modifiers();
             let keys = guard.serialize_pressed_keys();
             guard.with_focused_kbds(|kbd, surface| {

src/wayland/seat/mod.rs

@@ -125,7 +125,7 @@ impl Seat {
         let log = ::slog_or_stdlog(logger);
         let inner = Arc::new(Mutex::new(Inner {
             log: log.new(o!("smithay_module" => "seat_handler", "seat_name" => name.clone())),
-            name: name,
+            name,
             pointer: None,
             keyboard: None,
             known_seats: Vec::new(),

src/wayland/seat/pointer.rs

@@ -138,7 +138,7 @@ impl PointerHandle {
     ///
     /// A single frame will group multiple scroll events as if they happended in the same instance.
     /// Dropping the returned `PointerAxisHandle` will group the events together.
-    pub fn axis<'a>(&'a self) -> PointerAxisHandle<'a> {
+    pub fn axis(& self) -> PointerAxisHandle {
         PointerAxisHandle {
             inner: self.inner.lock().unwrap(),
         }

src/wayland/shell/legacy/mod.rs

@@ -345,7 +345,7 @@ where
         self::wl_handlers::implement_shell(
             shell,
             ltoken.clone(),
-            ctoken.clone(),
+            ctoken,
             implementation.clone(),
             state2.clone(),
         );

src/wayland/shell/legacy/wl_handlers.rs

@@ -45,17 +45,17 @@ pub(crate) fn implement_shell<U, R, D, Impl>(
                 surface,
                 implementation.clone(),
                 ltoken.clone(),
-                ctoken.clone(),
+                ctoken,
                 state.clone(),
             );
             state
                 .lock()
                 .unwrap()
                 .known_surfaces
-                .push(make_handle(&shell_surface, ctoken.clone()));
+                .push(make_handle(&shell_surface, ctoken));
             implementation.borrow_mut().receive(
                 ShellRequest::NewShellSurface {
-                    surface: make_handle(&shell_surface, ctoken.clone()),
+                    surface: make_handle(&shell_surface, ctoken),
                 },
                 (),
             );
@@ -117,7 +117,7 @@ where
                     if valid {
                         user_impl.receive(
                             ShellRequest::Pong {
-                                surface: make_handle(&shell_surface, ctoken.clone()),
+                                surface: make_handle(&shell_surface, ctoken),
                             },
                             (),
                         );
@@ -125,7 +125,7 @@ where
                 }
                 Request::Move { seat, serial } => user_impl.receive(
                     ShellRequest::Move {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         serial,
                         seat,
                     },
@@ -137,7 +137,7 @@ where
                     edges,
                 } => user_impl.receive(
                     ShellRequest::Resize {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         serial,
                         seat,
                         edges,
@@ -146,7 +146,7 @@ where
                 ),
                 Request::SetToplevel => user_impl.receive(
                     ShellRequest::SetKind {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         kind: ShellSurfaceKind::Toplevel,
                     },
                     (),
@@ -158,7 +158,7 @@ where
                     flags,
                 } => user_impl.receive(
                     ShellRequest::SetKind {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         kind: ShellSurfaceKind::Transient {
                             parent,
                             location: (x, y),
@@ -173,7 +173,7 @@ where
                     output,
                 } => user_impl.receive(
                     ShellRequest::SetKind {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         kind: ShellSurfaceKind::Fullscreen {
                             method,
                             framerate,
@@ -191,7 +191,7 @@ where
                     flags,
                 } => user_impl.receive(
                     ShellRequest::SetKind {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         kind: ShellSurfaceKind::Popup {
                             parent,
                             serial,
@@ -204,7 +204,7 @@ where
                 ),
                 Request::SetMaximized { output } => user_impl.receive(
                     ShellRequest::SetKind {
-                        surface: make_handle(&shell_surface, ctoken.clone()),
+                        surface: make_handle(&shell_surface, ctoken),
                         kind: ShellSurfaceKind::Maximized { output },
                     },
                     (),

src/wayland/shell/xdg/mod.rs

@@ -221,7 +221,7 @@ pub struct ToplevelState {
 impl Clone for ToplevelState {
     fn clone(&self) -> ToplevelState {
         ToplevelState {
-            parent: self.parent.as_ref().map(|p| p.clone()),
+            parent: self.parent.as_ref().cloned(),
             title: self.title.clone(),
             app_id: self.app_id.clone(),
             min_size: self.min_size,
@@ -242,7 +242,7 @@ pub struct PopupState {
 impl Clone for PopupState {
     fn clone(&self) -> PopupState {
         PopupState {
-            parent: self.parent.as_ref().map(|p| p.clone()),
+            parent: self.parent.as_ref().cloned(),
             positioner: self.positioner.clone(),
         }
     }
@@ -266,7 +266,7 @@ impl<U, R, SD> Clone for ShellImplementation<U, R, SD> {
     fn clone(&self) -> Self {
         ShellImplementation {
             log: self.log.clone(),
-            compositor_token: self.compositor_token.clone(),
+            compositor_token: self.compositor_token,
             loop_token: self.loop_token.clone(),
             user_impl: self.user_impl.clone(),
             shell_state: self.shell_state.clone(),

src/wayland/shell/xdg/xdg_handlers.rs

@@ -449,7 +449,7 @@ fn make_toplevel_handle<U, R, SD>(
     super::ToplevelSurface {
         wl_surface: wl_surface.clone(),
         shell_surface: ToplevelKind::Xdg(resource.clone()),
-        token: token,
+        token,
         _shell_data: ::std::marker::PhantomData,
     }
 }
@@ -650,7 +650,7 @@ fn make_popup_handle<U, R, SD>(
     super::PopupSurface {
         wl_surface: wl_surface.clone(),
         shell_surface: PopupKind::Xdg(resource.clone()),
-        token: token,
+        token,
         _shell_data: ::std::marker::PhantomData,
     }
 }

src/wayland/shell/xdg/zxdgv6_handlers.rs

@@ -466,7 +466,7 @@ fn make_toplevel_handle<U, R, SD>(
     super::ToplevelSurface {
         wl_surface: wl_surface.clone(),
         shell_surface: ToplevelKind::ZxdgV6(resource.clone()),
-        token: token,
+        token,
         _shell_data: ::std::marker::PhantomData,
     }
 }
@@ -671,7 +671,7 @@ fn make_popup_handle<U, R, SD>(
     super::PopupSurface {
         wl_surface: wl_surface.clone(),
         shell_surface: PopupKind::ZxdgV6(resource.clone()),
-        token: token,
+        token,
         _shell_data: ::std::marker::PhantomData,
     }
 }

src/wayland/shm/mod.rs

@@ -249,11 +249,11 @@ impl Implementation<Resource<wl_shm_pool::WlShmPool>, wl_shm_pool::Request> for
                 let data = Box::into_raw(Box::new(InternalBufferData {
                     pool: arc_pool.clone(),
                     data: BufferData {
-                        offset: offset,
+                        offset,
-                        width: width,
+                        width,
-                        height: height,
+                        height,
-                        stride: stride,
+                        stride,
-                        format: format,
+                        format,
                     },
                 }));
                 let buffer = buffer.implement_nonsend(

src/wayland/shm/pool.rs

@@ -28,8 +28,8 @@ impl Pool {
         trace!(log, "Creating new shm pool"; "fd" => fd as i32, "size" => size);
         Ok(Pool {
             map: RwLock::new(memmap),
-            fd: fd,
+            fd,
-            log: log,
+            log,
         })
     }
 
@@ -100,8 +100,8 @@ impl MemMap {
     fn new(fd: RawFd, size: usize) -> Result<MemMap, ()> {
         Ok(MemMap {
             ptr: unsafe { map(fd, size) }?,
-            fd: fd,
+            fd,
-            size: size,
+            size,
         })
     }
 

src/xwayland/x11_sockets.rs

@@ -19,7 +19,7 @@ pub(crate) fn prepare_x11_sockets(log: ::slog::Logger) -> Result<(X11Lock, [Unix
     }
     // If we reach here, all values from 0 to 32 failed
     // we need to stop trying at some point
-    return Err(());
+    Err(())
 }
 
 pub(crate) struct X11Lock {
@@ -40,15 +40,15 @@ impl X11Lock {
             Ok(mut file) => {
                 // we got it, write our PID in it and we're good
                 let ret = file.write_fmt(format_args!("{:>10}", ::nix::unistd::Pid::this()));
-                if let Err(_) = ret {
+                if ret.is_err() {
                     // write to the file failed ? we abandon
                     ::std::mem::drop(file);
                     let _ = ::std::fs::remove_file(&filename);
-                    return Err(());
+                    Err(())
                 } else {
                     debug!(log, "X11 lock aquired"; "D" => display);
                     // we got the lockfile and wrote our pid to it, all is good
-                    return Ok(X11Lock { display, log });
+                    Ok(X11Lock { display, log })
                 }
             }
             Err(_) => {
@@ -79,7 +79,7 @@ impl X11Lock {
                     }
                 }
                 // if we reach here, this lockfile exists and is probably in use, give up
-                return Err(());
+                Err(())
             }
         }
     }