Merge pull request #124 from Smithay/edition/2018

Migrate to Rust 2018 Edition

Cargo.toml

@@ -5,6 +5,7 @@ authors = ["Victor Berger <victor.berger@m4x.org>", "Drakulix (Victor Brekenfeld
 license = "MIT"
 description = "Smithay is a library for writing wayland compositors."
 repository = "https://github.com/Smithay/smithay"
+edition = "2018"
 
 [workspace]
 members = [ "anvil" ]

anvil/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.0.1"
 authors = ["Victor Berger <victor.berger@m4x.org>", "Drakulix (Victor Brekenfeld)"]
 license = "MIT"
 publish = false
+edition = "2018"
 
 [dependencies]
 slog = { version = "2.1.1" }

anvil/src/glium_drawer.rs

@@ -18,20 +18,20 @@ use smithay::{
         egl::{BufferAccessError, EGLImages, Format},
         graphics::{gl::GLGraphicsBackend, glium::GliumGraphicsBackend},
     },
+    reexports::wayland_server::{
+        protocol::{wl_buffer, wl_surface},
+        Resource,
+    },
     wayland::{
         compositor::{roles::Role, SubsurfaceRole, TraversalAction},
         data_device::DnDIconRole,
         seat::CursorImageRole,
         shm::with_buffer_contents as shm_buffer_contents,
     },
-    wayland_server::{
-        protocol::{wl_buffer, wl_surface},
-        Resource,
-    },
 };
 
-use shaders;
+use crate::shaders;
-use shell::{MyCompositorToken, MyWindowMap};
+use crate::shell::{MyCompositorToken, MyWindowMap};
 
 #[derive(Copy, Clone)]
 struct Vertex {
@@ -52,7 +52,7 @@ pub struct GliumDrawer<F: GLGraphicsBackend + 'static> {
 }
 
 impl<F: GLGraphicsBackend + 'static> GliumDrawer<F> {
-    pub fn borrow(&self) -> Ref<F> {
+    pub fn borrow(&self) -> Ref<'_, F> {
         self.display.borrow()
     }
 }
@@ -181,7 +181,7 @@ impl<F: GLGraphicsBackend + 'static> GliumDrawer<F> {
                 }
                 Ok(TextureMetadata {
                     texture: opengl_texture,
-                    fragment: ::shaders::BUFFER_RGBA,
+                    fragment: crate::shaders::BUFFER_RGBA,
                     y_inverted: images.y_inverted,
                     dimensions: (images.width, images.height),
                     images: Some(images), // I guess we need to keep this alive ?
@@ -205,7 +205,7 @@ impl<F: GLGraphicsBackend + 'static> GliumDrawer<F> {
 
     fn texture_from_shm_buffer(&self, buffer: Resource<wl_buffer::WlBuffer>) -> Result<TextureMetadata, ()> {
         match shm_buffer_contents(&buffer, |slice, data| {
-            ::shm_load::load_shm_buffer(data, slice)
+            crate::shm_load::load_shm_buffer(data, slice)
                 .map(|(image, kind)| (Texture2d::new(&self.display, image).unwrap(), kind, data))
         }) {
             Ok(Ok((texture, kind, data))) => Ok(TextureMetadata {

anvil/src/input_handler.rs

@@ -17,14 +17,14 @@ use smithay::{
         self, Event, InputBackend, InputHandler, KeyState, KeyboardKeyEvent, PointerAxisEvent,
         PointerButtonEvent, PointerMotionAbsoluteEvent, PointerMotionEvent,
     },
+    reexports::wayland_server::protocol::wl_pointer,
     wayland::{
         seat::{keysyms as xkb, AxisFrame, KeyboardHandle, Keysym, ModifiersState, PointerHandle},
         SERIAL_COUNTER as SCOUNTER,
     },
-    wayland_server::protocol::wl_pointer,
 };
 
-use shell::MyWindowMap;
+use crate::shell::MyWindowMap;
 
 pub struct AnvilInputHandler {
     log: Logger,

anvil/src/main.rs

@@ -1,16 +1,14 @@
+#![warn(rust_2018_idioms)]
+
 #[macro_use]
 extern crate glium;
-extern crate rand;
 #[macro_use]
 extern crate slog;
-extern crate slog_async;
-extern crate slog_term;
 #[macro_use(define_roles)]
 extern crate smithay;
-extern crate xkbcommon;
 
 use slog::Drain;
-use smithay::wayland_server::{calloop::EventLoop, Display};
+use smithay::reexports::wayland_server::{calloop::EventLoop, Display};
 
 #[macro_use]
 mod shaders;

anvil/src/shaders.rs

@@ -12,7 +12,7 @@ macro_rules! make_program(
     ($display: expr, $fragment_shader:expr) => {
         program!($display,
             100 => {
-                vertex: ::shaders::VERTEX_SHADER,
+                vertex: crate::shaders::VERTEX_SHADER,
                 fragment: $fragment_shader,
             },
         ).unwrap()
@@ -23,11 +23,11 @@ macro_rules! make_program(
 macro_rules! opengl_programs(
     ($display: expr) => {
         [
-            make_program!($display, ::shaders::FRAGMENT_SHADER_RGBA),
+            make_program!($display, crate::shaders::FRAGMENT_SHADER_RGBA),
-            make_program!($display, ::shaders::FRAGMENT_SHADER_ABGR),
+            make_program!($display, crate::shaders::FRAGMENT_SHADER_ABGR),
-            make_program!($display, ::shaders::FRAGMENT_SHADER_XBGR),
+            make_program!($display, crate::shaders::FRAGMENT_SHADER_XBGR),
-            make_program!($display, ::shaders::FRAGMENT_SHADER_BGRA),
+            make_program!($display, crate::shaders::FRAGMENT_SHADER_BGRA),
-            make_program!($display, ::shaders::FRAGMENT_SHADER_BGRX),
+            make_program!($display, crate::shaders::FRAGMENT_SHADER_BGRX),
         ]
     }
 );

anvil/src/shell.rs

@@ -7,6 +7,10 @@ use std::{
 use rand;
 
 use smithay::{
+    reexports::wayland_server::{
+        protocol::{wl_buffer, wl_callback, wl_shell_surface, wl_surface},
+        Display, Resource,
+    },
     wayland::{
         compositor::{compositor_init, CompositorToken, SurfaceAttributes, SurfaceEvent},
         data_device::DnDIconRole,
@@ -21,13 +25,9 @@ use smithay::{
             },
         },
     },
-    wayland_server::{
-        protocol::{wl_buffer, wl_callback, wl_shell_surface, wl_surface},
-        Display, Resource,
-    },
 };
 
-use window_map::{Kind as SurfaceKind, WindowMap};
+use crate::window_map::{Kind as SurfaceKind, WindowMap};
 
 define_roles!(Roles =>
     [ XdgSurface, XdgSurfaceRole ]
@@ -132,7 +132,7 @@ pub fn init_shell(
 #[derive(Default)]
 pub struct SurfaceData {
     pub buffer: Option<Resource<wl_buffer::WlBuffer>>,
-    pub texture: Option<::glium_drawer::TextureMetadata>,
+    pub texture: Option<crate::glium_drawer::TextureMetadata>,
 }
 
 fn surface_commit(surface: &Resource<wl_surface::WlSurface>, token: CompositorToken<SurfaceData, Roles>) {

anvil/src/shm_load.rs

@@ -1,10 +1,10 @@
 use std::borrow::Cow;
 
-use smithay::{wayland::shm::BufferData, wayland_server::protocol::wl_shm::Format};
+use smithay::{reexports::wayland_server::protocol::wl_shm::Format, wayland::shm::BufferData};
 
 use glium::texture::{ClientFormat, RawImage2d};
 
-pub fn load_shm_buffer(data: BufferData, pool: &[u8]) -> Result<(RawImage2d<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;
@@ -17,7 +17,7 @@ pub fn load_shm_buffer(data: BufferData, pool: &[u8]) -> Result<(RawImage2d<u8>,
     // ensure consistency, the SHM handler of smithay should ensure this
     assert!(offset + (height - 1) * stride + width * pixelsize <= pool.len());
 
-    let slice: Cow<[u8]> = if stride == width * pixelsize {
+    let slice: Cow<'_, [u8]> = if stride == width * pixelsize {
         // the buffer is cleanly continuous, use as-is
         Cow::Borrowed(&pool[offset..(offset + height * width * pixelsize)])
     } else {
@@ -33,10 +33,10 @@ pub fn load_shm_buffer(data: BufferData, pool: &[u8]) -> Result<(RawImage2d<u8>,
 
     // sharders format need to be reversed to account for endianness
     let (client_format, fragment) = match data.format {
-        Format::Argb8888 => (ClientFormat::U8U8U8U8, ::shaders::BUFFER_BGRA),
+        Format::Argb8888 => (ClientFormat::U8U8U8U8, crate::shaders::BUFFER_BGRA),
-        Format::Xrgb8888 => (ClientFormat::U8U8U8U8, ::shaders::BUFFER_BGRX),
+        Format::Xrgb8888 => (ClientFormat::U8U8U8U8, crate::shaders::BUFFER_BGRX),
-        Format::Rgba8888 => (ClientFormat::U8U8U8U8, ::shaders::BUFFER_ABGR),
+        Format::Rgba8888 => (ClientFormat::U8U8U8U8, crate::shaders::BUFFER_ABGR),
-        Format::Rgbx8888 => (ClientFormat::U8U8U8U8, ::shaders::BUFFER_XBGR),
+        Format::Rgbx8888 => (ClientFormat::U8U8U8U8, crate::shaders::BUFFER_XBGR),
         _ => return Err(data.format),
     };
     Ok((

anvil/src/udev.rs

@@ -61,9 +61,9 @@ use smithay::{
     },
 };
 
-use glium_drawer::GliumDrawer;
+use crate::glium_drawer::GliumDrawer;
-use input_handler::AnvilInputHandler;
+use crate::input_handler::AnvilInputHandler;
-use shell::{init_shell, MyWindowMap, Roles, SurfaceData};
+use crate::shell::{init_shell, MyWindowMap, Roles, SurfaceData};
 
 pub struct SessionFd(RawFd);
 impl AsRawFd for SessionFd {
@@ -110,7 +110,7 @@ pub fn run_udev(mut display: Display, mut event_loop: EventLoop<()>, log: Logger
     /*
      * Initialize the udev backend
      */
-    let context = ::smithay::udev::Context::new().map_err(|_| ())?;
+    let context = ::smithay::reexports::udev::Context::new().map_err(|_| ())?;
     let seat = session.seat();
 
     let primary_gpu = primary_gpu(&context, &seat).unwrap_or_default();

anvil/src/window_map.rs

@@ -1,4 +1,5 @@
 use smithay::{
+    reexports::wayland_server::{protocol::wl_surface, Resource},
     utils::Rectangle,
     wayland::{
         compositor::{roles::Role, CompositorToken, SubsurfaceRole, SurfaceAttributes, TraversalAction},
@@ -7,7 +8,6 @@ use smithay::{
             xdg::{ToplevelSurface, XdgSurfaceRole},
         },
     },
-    wayland_server::{protocol::wl_surface, Resource},
 };
 
 pub enum Kind<U, R, SD, D> {

anvil/src/winit.rs

@@ -6,20 +6,20 @@ use std::{
 
 use smithay::{
     backend::{egl::EGLGraphicsBackend, graphics::gl::GLGraphicsBackend, input::InputBackend, winit},
+    reexports::wayland_server::{calloop::EventLoop, protocol::wl_output, Display},
     wayland::{
         data_device::{default_action_chooser, init_data_device, set_data_device_focus, DataDeviceEvent},
         output::{Mode, Output, PhysicalProperties},
         seat::{CursorImageStatus, Seat, XkbConfig},
         shm::init_shm_global,
     },
-    wayland_server::{calloop::EventLoop, protocol::wl_output, Display},
 };
 
 use slog::Logger;
 
-use glium_drawer::GliumDrawer;
+use crate::glium_drawer::GliumDrawer;
-use input_handler::AnvilInputHandler;
+use crate::input_handler::AnvilInputHandler;
-use shell::init_shell;
+use crate::shell::init_shell;
 
 pub fn run_winit(display: &mut Display, event_loop: &mut EventLoop<()>, log: Logger) -> Result<(), ()> {
     let (renderer, mut input) = winit::init(log.clone()).map_err(|_| ())?;

examples/raw_drm.rs

@@ -1,7 +1,7 @@
-extern crate smithay;
+#![warn(rust_2018_idioms)]
+
 #[macro_use]
 extern crate slog;
-extern crate slog_term;
 
 use slog::Drain;
 use smithay::{
@@ -145,7 +145,7 @@ impl DeviceHandler for DrmHandlerImpl {
             // now we could render to the mapping via software rendering.
             // this example just sets some grey color
 
-            for mut x in mapping.as_mut() {
+            for x in mapping.as_mut() {
                 *x = 128;
             }
         }

src/backend/drm/egl/error.rs

@@ -3,7 +3,7 @@
 //! and [`EglSurface`](::backend::drm::egl::EglSurface).
 //!
 
-use backend::egl::error as egl;
+use crate::backend::egl::error as egl;
 
 error_chain! {
     errors {

src/backend/drm/egl/mod.rs

@@ -15,12 +15,12 @@ use std::rc::Rc;
 use wayland_server::Display;
 
 use super::{Device, DeviceHandler, Surface};
-use backend::egl::context::GlAttributes;
+use crate::backend::egl::context::GlAttributes;
-use backend::egl::error::Result as EGLResult;
+use crate::backend::egl::error::Result as EGLResult;
-use backend::egl::native::{Backend, NativeDisplay, NativeSurface};
+use crate::backend::egl::native::{Backend, NativeDisplay, NativeSurface};
-use backend::egl::EGLContext;
+use crate::backend::egl::EGLContext;
 #[cfg(feature = "native_lib")]
-use backend::egl::{EGLDisplay, EGLGraphicsBackend};
+use crate::backend::egl::{EGLDisplay, EGLGraphicsBackend};
 
 pub mod error;
 use self::error::*;
@@ -87,7 +87,7 @@ where
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_egl"));
+        let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_egl"));
 
         dev.clear_handler();
 
@@ -108,7 +108,7 @@ where
     D: Device + NativeDisplay<B, Arguments = crtc::Handle> + 'static,
     <D as Device>::Surface: NativeSurface,
 {
-    handler: Box<DeviceHandler<Device = EglDevice<B, D>> + 'static>,
+    handler: Box<dyn DeviceHandler<Device = EglDevice<B, D>> + 'static>,
 }
 
 impl<B, D> DeviceHandler for InternalDeviceHandler<B, D>

src/backend/drm/egl/session.rs

@@ -7,9 +7,9 @@ use drm::control::crtc;
 use std::os::unix::io::RawFd;
 
 use super::EglDevice;
-use backend::drm::Device;
+use crate::backend::drm::Device;
-use backend::egl::native::{Backend, NativeDisplay, NativeSurface};
+use crate::backend::egl::native::{Backend, NativeDisplay, NativeSurface};
-use backend::session::{AsSessionObserver, SessionObserver};
+use crate::backend::session::{AsSessionObserver, SessionObserver};
 
 /// [`SessionObserver`](SessionObserver)
 /// linked to the [`EglDevice`](EglDevice) it was

src/backend/drm/egl/surface.rs

@@ -3,14 +3,14 @@ use nix::libc::c_void;
 use std::rc::Rc;
 
 use super::error::*;
-use backend::drm::{Device, Surface};
+use crate::backend::drm::{Device, Surface};
-use backend::egl::native::{Backend, NativeDisplay, NativeSurface};
+use crate::backend::egl::native::{Backend, NativeDisplay, NativeSurface};
-use backend::egl::{EGLContext, EGLSurface};
+use crate::backend::egl::{EGLContext, EGLSurface};
 #[cfg(feature = "renderer_gl")]
-use backend::graphics::gl::GLGraphicsBackend;
+use crate::backend::graphics::gl::GLGraphicsBackend;
 #[cfg(feature = "renderer_gl")]
-use backend::graphics::PixelFormat;
+use crate::backend::graphics::PixelFormat;
-use backend::graphics::{CursorBackend, SwapBuffersError};
+use crate::backend::graphics::{CursorBackend, SwapBuffersError};
 
 /// Egl surface for rendering
 pub struct EglSurface<B, D>

src/backend/drm/gbm/egl.rs

@@ -4,11 +4,11 @@
 //! [`GbmDevice`](GbmDevice) and [`GbmSurface`](GbmSurface).
 //!
 
-use backend::drm::{Device, RawDevice};
+use crate::backend::drm::{Device, RawDevice};
-use backend::egl::error::Result as EglResult;
+use crate::backend::egl::error::Result as EglResult;
-use backend::egl::ffi;
+use crate::backend::egl::ffi;
-use backend::egl::native::{Backend, NativeDisplay, NativeSurface};
+use crate::backend::egl::native::{Backend, NativeDisplay, NativeSurface};
-use backend::graphics::SwapBuffersError;
+use crate::backend::graphics::SwapBuffersError;
 
 use super::error::{Error, Result};
 use super::{GbmDevice, GbmSurface};

src/backend/drm/gbm/error.rs

@@ -49,6 +49,6 @@ error_chain! {
     }
 
     foreign_links {
-        FailedToSwap(::backend::graphics::SwapBuffersError) #[doc = "Swapping front buffers failed"];
+        FailedToSwap(crate::backend::graphics::SwapBuffersError) #[doc = "Swapping front buffers failed"];
     }
 }

src/backend/drm/gbm/mod.rs

@@ -65,7 +65,7 @@ impl<D: RawDevice + ControlDevice + 'static> GbmDevice<D> {
             );
         });
 
-        let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_gbm"));
+        let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_gbm"));
 
         dev.clear_handler();
 
@@ -82,7 +82,7 @@ impl<D: RawDevice + ControlDevice + 'static> GbmDevice<D> {
 }
 
 struct InternalDeviceHandler<D: RawDevice + ControlDevice + 'static> {
-    handler: Box<DeviceHandler<Device = GbmDevice<D>> + 'static>,
+    handler: Box<dyn DeviceHandler<Device = GbmDevice<D>> + 'static>,
     backends: Weak<RefCell<HashMap<crtc::Handle, Weak<GbmSurfaceInternal<D>>>>>,
     logger: ::slog::Logger,
 }

src/backend/drm/gbm/session.rs

@@ -11,8 +11,8 @@ use std::os::unix::io::RawFd;
 use std::rc::{Rc, Weak};
 
 use super::{GbmDevice, GbmSurfaceInternal};
-use backend::drm::{RawDevice, RawSurface};
+use crate::backend::drm::{RawDevice, RawSurface};
-use backend::session::{AsSessionObserver, SessionObserver};
+use crate::backend::session::{AsSessionObserver, SessionObserver};
 
 /// [`SessionObserver`](SessionObserver)
 /// linked to the [`GbmDevice`](GbmDevice) it was

src/backend/drm/gbm/surface.rs

@@ -10,9 +10,9 @@ use std::os::unix::io::AsRawFd;
 use std::rc::Rc;
 
 #[cfg(feature = "backend_drm_legacy")]
-use backend::drm::legacy::LegacyDrmDevice;
+use crate::backend::drm::legacy::LegacyDrmDevice;
-use backend::graphics::CursorBackend;
+use crate::backend::graphics::CursorBackend;
-use backend::graphics::SwapBuffersError;
+use crate::backend::graphics::SwapBuffersError;
 
 pub(super) struct GbmSurfaceInternal<D: RawDevice + 'static> {
     pub(super) dev: Rc<RefCell<gbm::Device<D>>>,

src/backend/drm/legacy/error.rs

@@ -49,6 +49,6 @@ error_chain! {
     }
 
     foreign_links {
-        FailedToSwap(::backend::graphics::SwapBuffersError) #[doc = "Swapping front buffers failed"];
+        FailedToSwap(crate::backend::graphics::SwapBuffersError) #[doc = "Swapping front buffers failed"];
     }
 }

src/backend/drm/legacy/mod.rs

@@ -38,7 +38,7 @@ pub struct LegacyDrmDevice<A: AsRawFd + 'static> {
     dev_id: dev_t,
     active: Arc<AtomicBool>,
     backends: Rc<RefCell<HashMap<crtc::Handle, Weak<LegacyDrmSurfaceInternal<A>>>>>,
-    handler: Option<RefCell<Box<DeviceHandler<Device = LegacyDrmDevice<A>>>>>,
+    handler: Option<RefCell<Box<dyn DeviceHandler<Device = LegacyDrmDevice<A>>>>>,
     logger: ::slog::Logger,
 }
 
@@ -94,7 +94,7 @@ impl<A: AsRawFd + 'static> LegacyDrmDevice<A> {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_drm"));
+        let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_drm"));
         info!(log, "DrmDevice initializing");
 
         let dev_id = fstat(dev.as_raw_fd())

src/backend/drm/legacy/session.rs

@@ -15,7 +15,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
 use super::{Dev, LegacyDrmDevice, LegacyDrmSurfaceInternal};
-use backend::session::{AsSessionObserver, SessionObserver};
+use crate::backend::session::{AsSessionObserver, SessionObserver};
 
 /// [`SessionObserver`](SessionObserver)
 /// linked to the [`LegacyDrmDevice`](LegacyDrmDevice)

src/backend/drm/legacy/surface.rs

@@ -7,9 +7,9 @@ use std::os::unix::io::{AsRawFd, RawFd};
 use std::rc::Rc;
 use std::sync::RwLock;
 
-use backend::drm::{DevPath, RawSurface, Surface};
+use crate::backend::drm::{DevPath, RawSurface, Surface};
-use backend::graphics::CursorBackend;
+use crate::backend::graphics::CursorBackend;
-use backend::graphics::SwapBuffersError;
+use crate::backend::graphics::SwapBuffersError;
 
 use super::{error::*, Dev};
 
@@ -37,7 +37,7 @@ impl<A: AsRawFd + 'static> BasicDevice for LegacyDrmSurfaceInternal<A> {}
 impl<A: AsRawFd + 'static> ControlDevice for LegacyDrmSurfaceInternal<A> {}
 
 impl<'a, A: AsRawFd + 'static> CursorBackend<'a> for LegacyDrmSurfaceInternal<A> {
-    type CursorFormat = &'a Buffer;
+    type CursorFormat = &'a dyn Buffer;
     type Error = Error;
 
     fn set_cursor_position(&self, x: u32, y: u32) -> Result<()> {
@@ -250,7 +250,7 @@ impl<A: AsRawFd + 'static> BasicDevice for LegacyDrmSurface<A> {}
 impl<A: AsRawFd + 'static> ControlDevice for LegacyDrmSurface<A> {}
 
 impl<'a, A: AsRawFd + 'static> CursorBackend<'a> for LegacyDrmSurface<A> {
-    type CursorFormat = &'a Buffer;
+    type CursorFormat = &'a dyn Buffer;
     type Error = Error;
 
     fn set_cursor_position(&self, x: u32, y: u32) -> Result<()> {

src/backend/egl/context.rs

@@ -1,7 +1,7 @@
 //! EGL context related structs
 
 use super::{error::*, ffi, native, EGLSurface};
-use backend::graphics::PixelFormat;
+use crate::backend::graphics::PixelFormat;
 use nix::libc::{c_int, c_void};
 use slog;
 use std::{
@@ -36,7 +36,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger.into()).new(o!("smithay_module" => "renderer_egl"));
+        let log = crate::slog_or_stdlog(logger.into()).new(o!("smithay_module" => "renderer_egl"));
         let ptr = native.ptr()?;
         let (context, display, config_id, surface_attributes, pixel_format, wl_drm_support) =
             unsafe { EGLContext::<B, N>::new_internal(ptr, attributes, reqs, log.clone()) }?;
@@ -452,7 +452,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
     /// This follows the same semantics as [`std::cell:RefCell`](std::cell::RefCell).
     /// Multiple read-only borrows are possible. Borrowing the
     /// backend while there is a mutable reference will panic.
-    pub fn borrow(&self) -> Ref<N> {
+    pub fn borrow(&self) -> Ref<'_, N> {
         self.native.borrow()
     }
 
@@ -462,7 +462,7 @@ impl<B: native::Backend, N: native::NativeDisplay<B>> EGLContext<B, N> {
     /// Holding any other borrow while trying to borrow the backend
     /// mutably will panic. Note that EGL will borrow the display
     /// mutably during surface creation.
-    pub fn borrow_mut(&self) -> RefMut<N> {
+    pub fn borrow_mut(&self) -> RefMut<'_, N> {
         self.native.borrow_mut()
     }
 }

src/backend/egl/ffi.rs

@@ -13,7 +13,7 @@ pub type NativeDisplayType = *const c_void;
 pub type NativePixmapType = *const c_void;
 pub type NativeWindowType = *const c_void;
 
-#[cfg_attr(feature = "cargo-clippy", allow(clippy))]
+#[allow(clippy::all, rust_2018_idioms)]
 pub mod egl {
     use super::*;
     use libloading::Library;

src/backend/egl/mod.rs

@@ -19,7 +19,7 @@
 //! of an EGL-based [`WlBuffer`](wayland_server::protocol::wl_buffer::WlBuffer) for rendering.
 
 #[cfg(feature = "renderer_gl")]
-use backend::graphics::gl::ffi as gl_ffi;
+use crate::backend::graphics::gl::ffi as gl_ffi;
 use nix::libc::c_uint;
 use std::{
     ffi::CStr,
@@ -51,7 +51,7 @@ pub use self::surface::EGLSurface;
 pub struct EglExtensionNotSupportedError(&'static [&'static str]);
 
 impl fmt::Display for EglExtensionNotSupportedError {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> ::std::result::Result<(), fmt::Error> {
         write!(
             formatter,
             "None of the following EGL extensions is supported by the underlying EGL implementation,
@@ -66,7 +66,7 @@ impl ::std::error::Error for EglExtensionNotSupportedError {
         "The required EGL extension is not supported by the underlying EGL implementation"
     }
 
-    fn cause(&self) -> Option<&::std::error::Error> {
+    fn cause(&self) -> Option<&dyn ::std::error::Error> {
         None
     }
 }
@@ -84,7 +84,7 @@ pub enum BufferAccessError {
 }
 
 impl fmt::Debug for BufferAccessError {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> ::std::result::Result<(), fmt::Error> {
         match *self {
             BufferAccessError::ContextLost => write!(formatter, "BufferAccessError::ContextLost"),
             BufferAccessError::NotManaged(_) => write!(formatter, "BufferAccessError::NotManaged"),
@@ -97,7 +97,7 @@ impl fmt::Debug for BufferAccessError {
 }
 
 impl fmt::Display for BufferAccessError {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> ::std::result::Result<(), fmt::Error> {
         use std::error::Error;
         match *self {
             BufferAccessError::ContextLost
@@ -118,7 +118,7 @@ impl ::std::error::Error for BufferAccessError {
         }
     }
 
-    fn cause(&self) -> Option<&::std::error::Error> {
+    fn cause(&self) -> Option<&dyn ::std::error::Error> {
         match *self {
             BufferAccessError::EglExtensionNotSupported(ref err) => Some(err),
             _ => None,
@@ -158,7 +158,7 @@ pub enum TextureCreationError {
 }
 
 impl fmt::Display for TextureCreationError {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> ::std::result::Result<(), fmt::Error> {
         use std::error::Error;
         match *self {
             TextureCreationError::ContextLost => write!(formatter, "{}", self.description()),
@@ -185,7 +185,7 @@ impl ::std::error::Error for TextureCreationError {
         }
     }
 
-    fn cause(&self) -> Option<&::std::error::Error> {
+    fn cause(&self) -> Option<&dyn ::std::error::Error> {
         None
     }
 }

src/backend/egl/native.rs

@@ -1,7 +1,7 @@
 //! Type safe native types for safe context/surface creation
 
 use super::{error::*, ffi};
-use backend::graphics::SwapBuffersError;
+use crate::backend::graphics::SwapBuffersError;
 
 #[cfg(feature = "backend_winit")]
 use std::ptr;

src/backend/egl/surface.rs

@@ -1,7 +1,7 @@
 //! EGL surface related structs
 
 use super::{error::*, ffi, native, EGLContext};
-use backend::graphics::SwapBuffersError;
+use crate::backend::graphics::SwapBuffersError;
 use nix::libc::c_int;
 use std::{
     cell::Cell,

src/backend/graphics/errors.rs

@@ -22,7 +22,7 @@ pub enum SwapBuffersError {
 }
 
 impl fmt::Display for SwapBuffersError {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         use std::error::Error;
         write!(formatter, "{}", self.description())
     }
@@ -39,7 +39,7 @@ impl Error for SwapBuffersError {
         }
     }
 
-    fn cause(&self) -> Option<&Error> {
+    fn cause(&self) -> Option<&dyn Error> {
         None
     }
 }

src/backend/graphics/gl.rs

@@ -4,8 +4,7 @@ use nix::libc::c_void;
 
 use super::{PixelFormat, SwapBuffersError};
 
-#[cfg_attr(feature = "cargo-clippy", allow(clippy))]
+#[allow(clippy::all, rust_2018_idioms, missing_docs)]
-#[allow(missing_docs)]
 pub(crate) mod ffi {
     include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
 }

src/backend/graphics/glium.rs

@@ -1,6 +1,6 @@
 //! Glium compatibility module
 
-use backend::graphics::{gl::GLGraphicsBackend, SwapBuffersError};
+use crate::backend::graphics::{gl::GLGraphicsBackend, SwapBuffersError};
 use glium::{
     backend::{Backend, Context, Facade},
     debug::DebugCallbackBehavior,
@@ -59,7 +59,7 @@ impl<T: GLGraphicsBackend + 'static> GliumGraphicsBackend<T> {
     /// This follows the same semantics as [`std::cell::RefCell`](RefCell::borrow).
     /// Multiple read-only borrows are possible. Borrowing the
     /// backend while there is a mutable reference will panic.
-    pub fn borrow(&self) -> Ref<T> {
+    pub fn borrow(&self) -> Ref<'_, T> {
         self.backend.0.borrow()
     }
 
@@ -69,7 +69,7 @@ impl<T: GLGraphicsBackend + 'static> GliumGraphicsBackend<T> {
     /// Holding any other borrow while trying to borrow the backend
     /// mutably will panic. Note that Glium will borrow the backend
     /// (not mutably) during rendering.
-    pub fn borrow_mut(&self) -> RefMut<T> {
+    pub fn borrow_mut(&self) -> RefMut<'_, T> {
         self.backend.0.borrow_mut()
     }
 }

src/backend/input.rs

@@ -521,7 +521,7 @@ pub trait InputBackend: Sized {
     /// Sets a new handler for this [`InputBackend`]
     fn set_handler<H: InputHandler<Self> + 'static>(&mut self, handler: H);
     /// Get a reference to the currently set handler, if any
-    fn get_handler(&mut self) -> Option<&mut InputHandler<Self>>;
+    fn get_handler(&mut self) -> Option<&mut dyn InputHandler<Self>>;
     /// Clears the currently handler, if one is set
     fn clear_handler(&mut self);
 
@@ -626,7 +626,7 @@ pub trait InputHandler<B: InputBackend> {
     fn on_input_config_changed(&mut self, config: &mut B::InputConfig);
 }
 
-impl<B: InputBackend> InputHandler<B> for Box<InputHandler<B>> {
+impl<B: InputBackend> InputHandler<B> for Box<dyn InputHandler<B>> {
     fn on_seat_created(&mut self, seat: &Seat) {
         (**self).on_seat_created(seat)
     }

src/backend/libinput.rs

@@ -1,8 +1,8 @@
 //! Implementation of input backend trait for types provided by `libinput`
 
-use backend::input::{self as backend, Axis, InputBackend};
+use crate::backend::input::{self as backend, Axis, InputBackend};
 #[cfg(feature = "backend_session")]
-use backend::session::{AsErrno, Session, SessionObserver};
+use crate::backend::session::{AsErrno, Session, SessionObserver};
 use input as libinput;
 use input::event;
 
@@ -35,7 +35,7 @@ pub struct LibinputInputBackend {
     context: libinput::Libinput,
     devices: Vec<libinput::Device>,
     seats: HashMap<libinput::Seat, backend::Seat>,
-    handler: Option<Box<backend::InputHandler<LibinputInputBackend> + 'static>>,
+    handler: Option<Box<dyn backend::InputHandler<LibinputInputBackend> + 'static>>,
     logger: ::slog::Logger,
 }
 
@@ -46,7 +46,7 @@ impl LibinputInputBackend {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_libinput"));
+        let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_libinput"));
         info!(log, "Initializing a libinput backend");
         LibinputInputBackend {
             context,
@@ -275,10 +275,10 @@ impl InputBackend for LibinputInputBackend {
         self.handler = Some(Box::new(handler));
     }
 
-    fn get_handler(&mut self) -> Option<&mut backend::InputHandler<Self>> {
+    fn get_handler(&mut self) -> Option<&mut dyn backend::InputHandler<Self>> {
         self.handler
             .as_mut()
-            .map(|handler| handler as &mut backend::InputHandler<Self>)
+            .map(|handler| handler as &mut dyn backend::InputHandler<Self>)
     }
 
     fn clear_handler(&mut self) {
@@ -612,7 +612,7 @@ pub fn libinput_bind<Data: 'static>(
     source.set_interest(Ready::readable());
 
     handle.insert_source(source, move |evt, _| {
-        use backend::input::InputBackend;
+        use crate::backend::input::InputBackend;
 
         let mut backend = evt.source.borrow_mut();
         if let Err(error) = backend.0.dispatch_new_events() {

src/backend/session/auto.rs

@@ -88,7 +88,7 @@ impl AutoSession {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let logger = ::slog_or_stdlog(logger)
+        let logger = crate::slog_or_stdlog(logger)
             .new(o!("smithay_module" => "backend_session_auto", "session_type" => "auto"));
 
         info!(logger, "Trying to create logind session");
@@ -121,7 +121,7 @@ impl AutoSession {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let logger = ::slog_or_stdlog(logger)
+        let logger = crate::slog_or_stdlog(logger)
             .new(o!("smithay_module" => "backend_session_auto", "session_type" => "auto"));
 
         info!(logger, "Trying to create tty session");

src/backend/session/dbus/logind.rs

@@ -31,7 +31,7 @@
 //! It is crucial to avoid errors during that state. Examples for object that might be registered
 //! for notifications are the [`Libinput`](input::Libinput) context or the [`Device`](::backend::drm::Device).
 
-use backend::session::{AsErrno, Session, SessionNotifier, SessionObserver};
+use crate::backend::session::{AsErrno, Session, SessionNotifier, SessionObserver};
 use dbus::{
     BusName, BusType, Connection, ConnectionItem, ConnectionItems, Interface, Member, Message, MessageItem,
     OwnedFd, Path as DbusPath, Watch, WatchEvent,
@@ -60,7 +60,7 @@ struct LogindSessionImpl {
     conn: RefCell<Connection>,
     session_path: DbusPath<'static>,
     active: AtomicBool,
-    signals: RefCell<Vec<Option<Box<SessionObserver>>>>,
+    signals: RefCell<Vec<Option<Box<dyn SessionObserver>>>>,
     seat: String,
     logger: ::slog::Logger,
 }
@@ -84,7 +84,7 @@ impl LogindSession {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let logger = ::slog_or_stdlog(logger)
+        let logger = crate::slog_or_stdlog(logger)
             .new(o!("smithay_module" => "backend_session", "session_type" => "logind"));
 
         // Acquire session_id, seat and vt (if any) via libsystemd
@@ -246,7 +246,7 @@ impl LogindSessionImpl {
         }
     }
 
-    fn handle_signals(&self, signals: ConnectionItems) -> Result<()> {
+    fn handle_signals(&self, signals: ConnectionItems<'_>) -> Result<()> {
         for item in signals {
             let message = if let ConnectionItem::Signal(ref s) = item {
                 s
@@ -314,7 +314,7 @@ impl LogindSessionImpl {
                 use dbus::arg::{Array, Dict, Get, Iter, Variant};
 
                 let (_, changed, _) =
-                    message.get3::<String, Dict<String, Variant<Iter>, Iter>, Array<String, Iter>>();
+                    message.get3::<String, Dict<'_, String, Variant<Iter<'_>>, Iter<'_>>, Array<'_, String, Iter<'_>>>();
                 let mut changed = changed.chain_err(|| ErrorKind::UnexpectedMethodReturn)?;
                 if let Some((_, mut value)) = changed.find(|&(ref key, _)| &*key == "Active") {
                     if let Some(active) = Get::get(&mut value.0) {

src/backend/session/direct.rs

@@ -162,7 +162,7 @@ pub struct DirectSession {
 pub struct DirectSessionNotifier {
     tty: RawFd,
     active: Arc<AtomicBool>,
-    signals: Vec<Option<Box<SessionObserver>>>,
+    signals: Vec<Option<Box<dyn SessionObserver>>>,
     signal: Signal,
     logger: ::slog::Logger,
 }
@@ -175,7 +175,7 @@ impl DirectSession {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let logger = ::slog_or_stdlog(logger)
+        let logger = crate::slog_or_stdlog(logger)
             .new(o!("smithay_module" => "backend_session", "session_type" => "direct/vt"));
 
         let fd = tty

src/backend/session/multi.rs

@@ -16,26 +16,26 @@ static ID_COUNTER: AtomicUsize = AtomicUsize::new(0);
 pub struct Id(usize);
 
 struct MultiObserver {
-    observer: Arc<Mutex<HashMap<Id, Box<SessionObserver>>>>,
+    observer: Arc<Mutex<HashMap<Id, Box<dyn SessionObserver>>>>,
 }
 
 impl SessionObserver for MultiObserver {
     fn pause(&mut self, device: Option<(u32, u32)>) {
         let mut lock = self.observer.lock().unwrap();
-        for mut observer in lock.values_mut() {
+        for observer in lock.values_mut() {
             observer.pause(device)
         }
     }
     fn activate(&mut self, device: Option<(u32, u32, Option<RawFd>)>) {
         let mut lock = self.observer.lock().unwrap();
-        for mut observer in lock.values_mut() {
+        for observer in lock.values_mut() {
             observer.activate(device)
         }
     }
 }
 
 struct MultiNotifier {
-    observer: Arc<Mutex<HashMap<Id, Box<SessionObserver>>>>,
+    observer: Arc<Mutex<HashMap<Id, Box<dyn SessionObserver>>>>,
 }
 
 impl SessionNotifier for MultiNotifier {

src/backend/udev.rs

@@ -59,7 +59,7 @@ impl<T: UdevHandler + 'static> UdevBackend<T> {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_udev"));
+        let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_udev"));
 
         let devices = all_gpus(context, seat)?
             .into_iter()

src/backend/winit.rs

@@ -1,6 +1,6 @@
 //! Implementation of backend traits for types provided by `winit`
 
-use backend::{
+use crate::backend::{
     egl::{
         context::GlAttributes, error::Result as EGLResult, native, EGLContext, EGLDisplay,
         EGLGraphicsBackend, EGLSurface,
@@ -30,7 +30,7 @@ use winit::{
 
 /// Errors thrown by the `winit` backends
 pub mod errors {
-    use backend::egl::error as egl_error;
+    use crate::backend::egl::error as egl_error;
 
     error_chain! {
         errors {
@@ -64,7 +64,7 @@ enum Window {
 }
 
 impl Window {
-    fn window(&self) -> Ref<WinitWindow> {
+    fn window(&self) -> Ref<'_, WinitWindow> {
         match *self {
             Window::Wayland { ref context, .. } => context.borrow(),
             Window::X11 { ref context, .. } => context.borrow(),
@@ -91,13 +91,13 @@ pub struct WinitGraphicsBackend {
 /// periodically to receive any events.
 pub struct WinitInputBackend {
     events_loop: EventsLoop,
-    events_handler: Option<Box<WinitEventsHandler>>,
+    events_handler: Option<Box<dyn WinitEventsHandler>>,
     window: Rc<Window>,
     time: Instant,
     key_counter: u32,
     seat: Seat,
     input_config: (),
-    handler: Option<Box<InputHandler<WinitInputBackend> + 'static>>,
+    handler: Option<Box<dyn InputHandler<WinitInputBackend> + 'static>>,
     logger: ::slog::Logger,
     size: Rc<RefCell<WindowSize>>,
 }
@@ -152,7 +152,7 @@ pub fn init_from_builder_with_gl_attr<L>(
 where
     L: Into<Option<::slog::Logger>>,
 {
-    let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_winit"));
+    let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "backend_winit"));
     info!(log, "Initializing a winit backend");
 
     let events_loop = EventsLoop::new();
@@ -162,12 +162,12 @@ where
     let reqs = Default::default();
     let window = Rc::new(
         if native::NativeDisplay::<native::Wayland>::is_backend(&winit_window) {
-            let mut context =
+            let context =
                 EGLContext::<native::Wayland, WinitWindow>::new(winit_window, attributes, reqs, log.clone())?;
             let surface = context.create_surface(())?;
             Window::Wayland { context, surface }
         } else if native::NativeDisplay::<native::X11>::is_backend(&winit_window) {
-            let mut context =
+            let context =
                 EGLContext::<native::X11, WinitWindow>::new(winit_window, attributes, reqs, log.clone())?;
             let surface = context.create_surface(())?;
             Window::X11 { context, surface }
@@ -227,7 +227,7 @@ pub trait WinitEventsHandler {
 
 impl WinitGraphicsBackend {
     /// Get a reference to the internally used [`WinitWindow`]
-    pub fn winit_window(&self) -> Ref<WinitWindow> {
+    pub fn winit_window(&self) -> Ref<'_, WinitWindow> {
         self.window.window()
     }
 }
@@ -339,7 +339,7 @@ impl ::std::error::Error for WinitInputError {
 }
 
 impl fmt::Display for WinitInputError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(f, "{}", self.description())
     }
@@ -606,10 +606,10 @@ impl WinitInputBackend {
     }
 
     /// Get a reference to the set events handler, if any
-    pub fn get_events_handler(&mut self) -> Option<&mut WinitEventsHandler> {
+    pub fn get_events_handler(&mut self) -> Option<&mut dyn WinitEventsHandler> {
         self.events_handler
             .as_mut()
-            .map(|handler| &mut **handler as &mut WinitEventsHandler)
+            .map(|handler| &mut **handler as &mut dyn WinitEventsHandler)
     }
 
     /// Clear out the currently set events handler
@@ -644,10 +644,10 @@ impl InputBackend for WinitInputBackend {
         self.handler = Some(Box::new(handler));
     }
 
-    fn get_handler(&mut self) -> Option<&mut InputHandler<Self>> {
+    fn get_handler(&mut self) -> Option<&mut dyn InputHandler<Self>> {
         self.handler
             .as_mut()
-            .map(|handler| handler as &mut InputHandler<Self>)
+            .map(|handler| handler as &mut dyn InputHandler<Self>)
     }
 
     fn clear_handler(&mut self) {
@@ -683,8 +683,8 @@ impl InputBackend for WinitInputBackend {
             // upcoming closure, which is why all are borrowed manually and the
             // assignments are then moved into the closure to avoid rustc's
             // wrong interference.
-            let mut closed_ptr = &mut closed;
+            let closed_ptr = &mut closed;
-            let mut key_counter = &mut self.key_counter;
+            let key_counter = &mut self.key_counter;
             let time = &self.time;
             let seat = &self.seat;
             let window = &self.window;

src/lib.rs

@@ -1,4 +1,4 @@
-#![warn(missing_docs)]
+#![warn(missing_docs, rust_2018_idioms)]
 //! **Smithay: the Wayland compositor smithy**
 //!
 //! Most entry points in the modules can take an optional [`slog::Logger`](::slog::Logger) as argument
@@ -7,58 +7,13 @@
 // `error_chain!` can recurse deeply
 #![recursion_limit = "1024"]
 
-#[cfg(feature = "backend_drm_gbm")]
-#[doc(hidden)]
-pub extern crate image;
 #[cfg_attr(feature = "backend_session", macro_use)]
 #[doc(hidden)]
 pub extern crate nix;
-extern crate tempfile;
-#[doc(hidden)]
-pub extern crate wayland_commons;
-#[doc(hidden)]
-pub extern crate wayland_protocols;
-#[doc(hidden)]
-pub extern crate wayland_server;
-#[cfg(feature = "native_lib")]
-extern crate wayland_sys;
-extern crate xkbcommon;
-
-#[cfg(feature = "dbus")]
-#[doc(hidden)]
-pub extern crate dbus;
-#[cfg(feature = "backend_drm")]
-#[doc(hidden)]
-pub extern crate drm;
-#[cfg(feature = "backend_drm_gbm")]
-#[doc(hidden)]
-pub extern crate gbm;
-#[cfg(feature = "backend_libinput")]
-#[doc(hidden)]
-pub extern crate input;
-#[cfg(feature = "backend_session_logind")]
-#[doc(hidden)]
-pub extern crate systemd;
-#[cfg(feature = "backend_udev")]
-#[doc(hidden)]
-pub extern crate udev;
-#[cfg(feature = "backend_winit")]
-extern crate wayland_client;
-#[cfg(feature = "backend_winit")]
-extern crate winit;
-
-extern crate libloading;
-
-#[cfg(feature = "renderer_glium")]
-extern crate glium;
-
 #[macro_use]
 extern crate slog;
-extern crate slog_stdlog;
-
 #[macro_use]
 extern crate error_chain;
-
 #[macro_use]
 extern crate lazy_static;
 

src/wayland/compositor/handlers.rs

@@ -51,7 +51,7 @@ where
 // Internal implementation data of surfaces
 pub(crate) struct SurfaceImplem<U, R> {
     log: ::slog::Logger,
-    implem: Rc<RefCell<FnMut(SurfaceEvent, Resource<wl_surface::WlSurface>, CompositorToken<U, R>)>>,
+    implem: Rc<RefCell<dyn FnMut(SurfaceEvent, Resource<wl_surface::WlSurface>, CompositorToken<U, R>)>>,
 }
 
 impl<U, R> SurfaceImplem<U, R> {

src/wayland/compositor/mod.rs

@@ -90,7 +90,7 @@ use self::{
     roles::{Role, RoleType, WrongRole},
     tree::SurfaceData,
 };
-use utils::Rectangle;
+use crate::utils::Rectangle;
 use wayland_server::{
     protocol::{
         wl_buffer, wl_callback, wl_compositor, wl_output, wl_region, wl_subcompositor, wl_surface::WlSurface,
@@ -467,7 +467,7 @@ where
     R: Default + RoleType + Role<SubsurfaceRole> + 'static,
     Impl: FnMut(SurfaceEvent, Resource<WlSurface>, CompositorToken<U, R>) + 'static,
 {
-    let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "compositor_handler"));
+    let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "compositor_handler"));
     let implem = Rc::new(RefCell::new(implem));
 
     let comp_token = display.get_token();

src/wayland/data_device/dnd_grab.rs

@@ -8,7 +8,7 @@ use wayland_server::{
     NewResource, Resource,
 };
 
-use wayland::{
+use crate::wayland::{
     compositor::{roles::Role, CompositorToken},
     seat::{AxisFrame, PointerGrab, PointerInnerHandle, Seat},
 };
@@ -22,7 +22,7 @@ pub(crate) struct DnDGrab<U, R> {
     offer_data: Option<Arc<Mutex<OfferData>>>,
     icon: Option<Resource<wl_surface::WlSurface>>,
     origin: Resource<wl_surface::WlSurface>,
-    callback: Arc<Mutex<FnMut(super::DataDeviceEvent) + Send>>,
+    callback: Arc<Mutex<dyn FnMut(super::DataDeviceEvent) + Send>>,
     token: CompositorToken<U, R>,
     seat: Seat,
 }
@@ -34,7 +34,7 @@ impl<U: 'static, R: Role<DnDIconRole> + 'static> DnDGrab<U, R> {
         seat: Seat,
         icon: Option<Resource<wl_surface::WlSurface>>,
         token: CompositorToken<U, R>,
-        callback: Arc<Mutex<FnMut(super::DataDeviceEvent) + Send>>,
+        callback: Arc<Mutex<dyn FnMut(super::DataDeviceEvent) + Send>>,
     ) -> DnDGrab<U, R> {
         DnDGrab {
             data_source: source,
@@ -53,7 +53,7 @@ impl<U: 'static, R: Role<DnDIconRole> + 'static> DnDGrab<U, R> {
 impl<U: 'static, R: Role<DnDIconRole> + 'static> PointerGrab for DnDGrab<U, R> {
     fn motion(
         &mut self,
-        _handle: &mut PointerInnerHandle,
+        _handle: &mut PointerInnerHandle<'_>,
         location: (f64, f64),
         focus: Option<(Resource<wl_surface::WlSurface>, (f64, f64))>,
         serial: u32,
@@ -179,7 +179,7 @@ impl<U: 'static, R: Role<DnDIconRole> + 'static> PointerGrab for DnDGrab<U, R> {
 
     fn button(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         _button: u32,
         _state: wl_pointer::ButtonState,
         serial: u32,
@@ -239,7 +239,7 @@ impl<U: 'static, R: Role<DnDIconRole> + 'static> PointerGrab for DnDGrab<U, R> {
         }
     }
 
-    fn axis(&mut self, handle: &mut PointerInnerHandle, details: AxisFrame) {
+    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
         // we just forward the axis events as is
         handle.axis(details);
     }
@@ -256,7 +256,7 @@ fn implement_dnd_data_offer(
     offer: NewResource<wl_data_offer::WlDataOffer>,
     source: Resource<wl_data_source::WlDataSource>,
     offer_data: Arc<Mutex<OfferData>>,
-    action_choice: Arc<Mutex<FnMut(DndAction, DndAction) -> DndAction + Send + 'static>>,
+    action_choice: Arc<Mutex<dyn FnMut(DndAction, DndAction) -> DndAction + Send + 'static>>,
 ) -> Resource<wl_data_offer::WlDataOffer> {
     use self::wl_data_offer::Request;
     offer.implement(

src/wayland/data_device/mod.rs

@@ -68,7 +68,7 @@ use wayland_server::{
     Client, Display, Global, NewResource, Resource,
 };
 
-use wayland::{
+use crate::wayland::{
     compositor::{roles::Role, CompositorToken},
     seat::Seat,
 };
@@ -294,7 +294,7 @@ where
     U: 'static,
     L: Into<Option<::slog::Logger>>,
 {
-    let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "data_device_mgr"));
+    let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "data_device_mgr"));
     let action_choice = Arc::new(Mutex::new(action_choice));
     let callback = Arc::new(Mutex::new(callback));
     let global = display.create_global(3, move |new_ddm, _version| {
@@ -419,8 +419,8 @@ where
 }
 
 struct DataDeviceData {
-    callback: Arc<Mutex<FnMut(DataDeviceEvent) + Send + 'static>>,
+    callback: Arc<Mutex<dyn FnMut(DataDeviceEvent) + Send + 'static>>,
-    action_choice: Arc<Mutex<FnMut(DndAction, DndAction) -> DndAction + Send + 'static>>,
+    action_choice: Arc<Mutex<dyn FnMut(DndAction, DndAction) -> DndAction + Send + 'static>>,
 }
 
 fn implement_data_device<F, C, U, R>(

src/wayland/data_device/server_dnd_grab.rs

@@ -6,7 +6,7 @@ use wayland_server::{
     NewResource, Resource,
 };
 
-use wayland::seat::{AxisFrame, PointerGrab, PointerInnerHandle, Seat};
+use crate::wayland::seat::{AxisFrame, PointerGrab, PointerInnerHandle, Seat};
 
 use super::{DataDeviceData, SeatData};
 
@@ -67,7 +67,7 @@ where
 {
     fn motion(
         &mut self,
-        _handle: &mut PointerInnerHandle,
+        _handle: &mut PointerInnerHandle<'_>,
         location: (f64, f64),
         focus: Option<(Resource<wl_surface::WlSurface>, (f64, f64))>,
         serial: u32,
@@ -169,7 +169,7 @@ where
 
     fn button(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         _button: u32,
         _state: wl_pointer::ButtonState,
         serial: u32,
@@ -220,7 +220,7 @@ where
         }
     }
 
-    fn axis(&mut self, handle: &mut PointerInnerHandle, details: AxisFrame) {
+    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
         // we just forward the axis events as is
         handle.axis(details);
     }
@@ -238,7 +238,7 @@ fn implement_dnd_data_offer<C>(
     metadata: super::SourceMetadata,
     offer_data: Arc<Mutex<OfferData>>,
     callback: Arc<Mutex<C>>,
-    action_choice: Arc<Mutex<FnMut(DndAction, DndAction) -> DndAction + Send + 'static>>,
+    action_choice: Arc<Mutex<dyn FnMut(DndAction, DndAction) -> DndAction + Send + 'static>>,
 ) -> Resource<wl_data_offer::WlDataOffer>
 where
     C: FnMut(ServerDndEvent) + Send + 'static,

src/wayland/output/mod.rs

@@ -179,7 +179,7 @@ impl Output {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger).new(o!("smithay_module" => "output_handler"));
+        let log = crate::slog_or_stdlog(logger).new(o!("smithay_module" => "output_handler"));
 
         info!(log, "Creating new wl_output"; "name" => &name);
 

src/wayland/seat/keyboard.rs

@@ -1,4 +1,4 @@
-use backend::input::KeyState;
+use crate::backend::input::KeyState;
 use std::{
     default::Default,
     io::{Error as IoError, Write},
@@ -112,7 +112,7 @@ struct KbdInternal {
     state: xkb::State,
     repeat_rate: i32,
     repeat_delay: i32,
-    focus_hook: Box<FnMut(Option<&Resource<WlSurface>>)>,
+    focus_hook: Box<dyn FnMut(Option<&Resource<WlSurface>>)>,
 }
 
 // This is OK because all parts of `xkb` will remain on the
@@ -121,10 +121,10 @@ unsafe impl Send for KbdInternal {}
 
 impl KbdInternal {
     fn new(
-        xkb_config: XkbConfig,
+        xkb_config: XkbConfig<'_>,
         repeat_rate: i32,
         repeat_delay: i32,
-        focus_hook: Box<FnMut(Option<&Resource<WlSurface>>)>,
+        focus_hook: Box<dyn FnMut(Option<&Resource<WlSurface>>)>,
     ) -> Result<KbdInternal, ()> {
         // we create a new contex for each keyboard because libxkbcommon is actually NOT threadsafe
         // so confining it inside the KbdInternal allows us to use Rusts mutability rules to make
@@ -228,7 +228,7 @@ pub enum Error {
 
 /// Create a keyboard handler from a set of RMLVO rules
 pub(crate) fn create_keyboard_handler<F>(
-    xkb_config: XkbConfig,
+    xkb_config: XkbConfig<'_>,
     repeat_delay: i32,
     repeat_rate: i32,
     logger: &::slog::Logger,

src/wayland/seat/mod.rs

@@ -55,7 +55,7 @@ pub use self::{
     },
 };
 
-use wayland::compositor::{roles::Role, CompositorToken};
+use crate::wayland::compositor::{roles::Role, CompositorToken};
 
 use wayland_commons::utils::UserDataMap;
 
@@ -133,7 +133,7 @@ impl Seat {
         R: Role<CursorImageRole> + 'static,
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger);
+        let log = crate::slog_or_stdlog(logger);
         let arc = Arc::new(SeatArc {
             inner: Mutex::new(Inner {
                 pointer: None,
@@ -281,7 +281,7 @@ impl Seat {
     /// ```
     pub fn add_keyboard<F>(
         &mut self,
-        xkb_config: keyboard::XkbConfig,
+        xkb_config: keyboard::XkbConfig<'_>,
         repeat_delay: i32,
         repeat_rate: i32,
         mut focus_hook: F,

src/wayland/seat/pointer.rs

@@ -7,7 +7,7 @@ use wayland_server::{
     NewResource, Resource,
 };
 
-use wayland::compositor::{roles::Role, CompositorToken};
+use crate::wayland::compositor::{roles::Role, CompositorToken};
 
 /// The role representing a surface set as the pointer cursor
 #[derive(Default, Copy, Clone)]
@@ -29,7 +29,7 @@ pub enum CursorImageStatus {
 
 enum GrabStatus {
     None,
-    Active(u32, Box<PointerGrab>),
+    Active(u32, Box<dyn PointerGrab>),
     Borrowed,
 }
 
@@ -40,7 +40,7 @@ struct PointerInternal {
     location: (f64, f64),
     grab: GrabStatus,
     pressed_buttons: Vec<u32>,
-    image_callback: Box<FnMut(CursorImageStatus) + Send>,
+    image_callback: Box<dyn FnMut(CursorImageStatus) + Send>,
 }
 
 impl PointerInternal {
@@ -95,7 +95,7 @@ impl PointerInternal {
 
     fn with_grab<F>(&mut self, f: F)
     where
-        F: FnOnce(PointerInnerHandle, &mut PointerGrab),
+        F: FnOnce(PointerInnerHandle<'_>, &mut dyn PointerGrab),
     {
         let mut grab = ::std::mem::replace(&mut self.grab, GrabStatus::Borrowed);
         match grab {
@@ -239,7 +239,7 @@ pub trait PointerGrab: Send + Sync {
     /// A motion was reported
     fn motion(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         location: (f64, f64),
         focus: Option<(Resource<WlSurface>, (f64, f64))>,
         serial: u32,
@@ -248,14 +248,14 @@ pub trait PointerGrab: Send + Sync {
     /// A button press was reported
     fn button(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         button: u32,
         state: ButtonState,
         serial: u32,
         time: u32,
     );
     /// An axis scroll was reported
-    fn axis(&mut self, handle: &mut PointerInnerHandle, details: AxisFrame);
+    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame);
 }
 
 /// This inner handle is accessed from inside a pointer grab logic, and directly
@@ -644,7 +644,7 @@ struct DefaultGrab;
 impl PointerGrab for DefaultGrab {
     fn motion(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         location: (f64, f64),
         focus: Option<(Resource<WlSurface>, (f64, f64))>,
         serial: u32,
@@ -654,7 +654,7 @@ impl PointerGrab for DefaultGrab {
     }
     fn button(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         button: u32,
         state: ButtonState,
         serial: u32,
@@ -670,7 +670,7 @@ impl PointerGrab for DefaultGrab {
             },
         );
     }
-    fn axis(&mut self, handle: &mut PointerInnerHandle, details: AxisFrame) {
+    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
         handle.axis(details);
     }
 }
@@ -688,7 +688,7 @@ struct ClickGrab {
 impl PointerGrab for ClickGrab {
     fn motion(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         location: (f64, f64),
         focus: Option<(Resource<WlSurface>, (f64, f64))>,
         serial: u32,
@@ -700,7 +700,7 @@ impl PointerGrab for ClickGrab {
     }
     fn button(
         &mut self,
-        handle: &mut PointerInnerHandle,
+        handle: &mut PointerInnerHandle<'_>,
         button: u32,
         state: ButtonState,
         serial: u32,
@@ -712,7 +712,7 @@ impl PointerGrab for ClickGrab {
             handle.unset_grab(serial, time);
         }
     }
-    fn axis(&mut self, handle: &mut PointerInnerHandle, details: AxisFrame) {
+    fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
         handle.axis(details);
     }
 }

src/wayland/shell/legacy/mod.rs

@@ -76,7 +76,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use wayland::compositor::{roles::Role, CompositorToken};
+use crate::wayland::compositor::{roles::Role, CompositorToken};
 
 use wayland_server::{
     protocol::{wl_output, wl_seat, wl_shell, wl_shell_surface, wl_surface},
@@ -327,7 +327,7 @@ where
     L: Into<Option<::slog::Logger>>,
     Impl: FnMut(ShellRequest<U, R, D>) + 'static,
 {
-    let _log = ::slog_or_stdlog(logger);
+    let _log = crate::slog_or_stdlog(logger);
 
     let implementation = Rc::new(RefCell::new(implementation));
 

src/wayland/shell/legacy/wl_handlers.rs

@@ -9,7 +9,7 @@ use wayland_server::{
     DisplayToken, NewResource, Resource,
 };
 
-use wayland::compositor::{roles::Role, CompositorToken};
+use crate::wayland::compositor::{roles::Role, CompositorToken};
 
 use super::{ShellRequest, ShellState, ShellSurface, ShellSurfaceKind, ShellSurfaceRole};
 

src/wayland/shell/xdg/mod.rs

@@ -90,13 +90,13 @@
 //! the subhandler you provided, or via methods on the [`ShellState`](::wayland::shell::xdg::ShellState)
 //! that you are given (in an `Arc<Mutex<_>>`) as return value of the `init` function.
 
+use crate::utils::Rectangle;
+use crate::wayland::compositor::{roles::Role, CompositorToken};
 use std::{
     cell::RefCell,
     rc::Rc,
     sync::{Arc, Mutex},
 };
-use utils::Rectangle;
-use wayland::compositor::{roles::Role, CompositorToken};
 use wayland_protocols::{
     unstable::xdg_shell::v6::server::{zxdg_popup_v6, zxdg_shell_v6, zxdg_surface_v6, zxdg_toplevel_v6},
     xdg_shell::server::{xdg_popup, xdg_positioner, xdg_surface, xdg_toplevel, xdg_wm_base},
@@ -263,7 +263,7 @@ pub(crate) struct ShellData<U, R, SD> {
     log: ::slog::Logger,
     compositor_token: CompositorToken<U, R>,
     display_token: DisplayToken,
-    user_impl: Rc<RefCell<FnMut(XdgRequest<U, R, SD>)>>,
+    user_impl: Rc<RefCell<dyn FnMut(XdgRequest<U, R, SD>)>>,
     shell_state: Arc<Mutex<ShellState<U, R, SD>>>,
 }
 
@@ -297,7 +297,7 @@ where
     L: Into<Option<::slog::Logger>>,
     Impl: FnMut(XdgRequest<U, R, SD>) + 'static,
 {
-    let log = ::slog_or_stdlog(logger);
+    let log = crate::slog_or_stdlog(logger);
     let shell_state = Arc::new(Mutex::new(ShellState {
         known_toplevels: Vec::new(),
         known_popups: Vec::new(),

src/wayland/shell/xdg/xdg_handlers.rs

@@ -1,12 +1,12 @@
 use std::{cell::RefCell, sync::Mutex};
 
-use wayland::compositor::{roles::*, CompositorToken};
+use crate::wayland::compositor::{roles::*, CompositorToken};
 use wayland_protocols::xdg_shell::server::{
     xdg_popup, xdg_positioner, xdg_surface, xdg_toplevel, xdg_wm_base,
 };
 use wayland_server::{protocol::wl_surface, DisplayToken, NewResource, Resource};
 
-use utils::Rectangle;
+use crate::utils::Rectangle;
 
 use super::{
     make_shell_client_data, PopupConfigure, PopupKind, PopupState, PositionerState, ShellClient,

src/wayland/shell/xdg/zxdgv6_handlers.rs

@@ -1,6 +1,6 @@
 use std::{cell::RefCell, sync::Mutex};
 
-use wayland::compositor::{roles::*, CompositorToken};
+use crate::wayland::compositor::{roles::*, CompositorToken};
 use wayland_protocols::{
     unstable::xdg_shell::v6::server::{
         zxdg_popup_v6, zxdg_positioner_v6, zxdg_shell_v6, zxdg_surface_v6, zxdg_toplevel_v6,
@@ -9,7 +9,7 @@ use wayland_protocols::{
 };
 use wayland_server::{protocol::wl_surface, DisplayToken, NewResource, Resource};
 
-use utils::Rectangle;
+use crate::utils::Rectangle;
 
 use super::{
     make_shell_client_data, PopupConfigure, PopupKind, PopupState, PositionerState, ShellClient,

src/wayland/shm/mod.rs

@@ -115,7 +115,7 @@ pub fn init_shm_global<L>(
 where
     L: Into<Option<::slog::Logger>>,
 {
-    let log = ::slog_or_stdlog(logger);
+    let log = crate::slog_or_stdlog(logger);
 
     // always add the mandatory formats
     formats.push(wl_shm::Format::Argb8888);

src/xwayland/xserver.rs

@@ -86,7 +86,7 @@ impl<WM: XWindowManager + 'static> XWayland<WM> {
     where
         L: Into<Option<::slog::Logger>>,
     {
-        let log = ::slog_or_stdlog(logger);
+        let log = crate::slog_or_stdlog(logger);
         let inner = Rc::new(RefCell::new(Inner {
             wm,
             source_maker: Box::new(move |inner| {
@@ -127,7 +127,7 @@ struct XWaylandInstance {
 // Inner implementation of the XWayland manager
 struct Inner<WM: XWindowManager> {
     wm: WM,
-    source_maker: Box<FnMut(Rc<RefCell<Inner<WM>>>) -> Result<Source<Signals>, ()>>,
+    source_maker: Box<dyn FnMut(Rc<RefCell<Inner<WM>>>) -> Result<Source<Signals>, ()>>,
     wayland_display: Rc<RefCell<Display>>,
     instance: Option<XWaylandInstance>,
     log: ::slog::Logger,