Fix source code for 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

@@ -30,8 +30,8 @@ use smithay::{
     },
 };
 
-use shaders;
+use crate::shaders;
-use shell::{MyCompositorToken, MyWindowMap};
+use crate::shell::{MyCompositorToken, MyWindowMap};
 
 #[derive(Copy, Clone)]
 struct Vertex {
@@ -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

@@ -24,7 +24,7 @@ use smithay::{
     wayland_server::protocol::wl_pointer,
 };
 
-use shell::MyWindowMap;
+use crate::shell::MyWindowMap;
 
 pub struct AnvilInputHandler {
     log: Logger,

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

@@ -27,7 +27,7 @@ use smithay::{
     },
 };
 
-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

@@ -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 {

anvil/src/winit.rs

@@ -17,9 +17,9 @@ use smithay::{
 
 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(|_| ())?;

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();
 

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();
 

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

@@ -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};
 

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()) }?;

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,

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/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,

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;
 
@@ -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,
@@ -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,
@@ -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

src/backend/session/direct.rs

@@ -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/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 {
@@ -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();

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},
 };

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| {

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};
 

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},

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,

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)]

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

@@ -95,8 +95,8 @@ use std::{
     rc::Rc,
     sync::{Arc, Mutex},
 };
-use utils::Rectangle;
+use crate::utils::Rectangle;
-use wayland::compositor::{roles::Role, CompositorToken};
+use crate::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},
@@ -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| {