autocommit 2022-04-07 17:31:31 CEST

src/utils/asyncevent.rs

@@ -1,8 +1,12 @@
-use crate::utils::numcell::NumCell;
-use std::cell::Cell;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll, Waker};
+use {
+    crate::utils::numcell::NumCell,
+    std::{
+        cell::Cell,
+        future::Future,
+        pin::Pin,
+        task::{Context, Poll, Waker},
+    },
+};
 
 #[derive(Default)]
 pub struct AsyncEvent {

src/utils/buffd.rs

@@ -1,9 +1,10 @@
-use crate::async_engine::AsyncError;
-pub use buf_in::BufFdIn;
-pub use buf_out::{BufFdOut, OutBuffer, OutBufferSwapchain};
-pub use formatter::MsgFormatter;
-pub use parser::{MsgParser, MsgParserError};
-use thiserror::Error;
+use {crate::async_engine::AsyncError, thiserror::Error};
+pub use {
+    buf_in::BufFdIn,
+    buf_out::{BufFdOut, OutBuffer, OutBufferSwapchain},
+    formatter::MsgFormatter,
+    parser::{MsgParser, MsgParserError},
+};
 
 mod buf_in;
 mod buf_out;

src/utils/buffd/buf_in.rs

@@ -1,8 +1,11 @@
-use crate::async_engine::AsyncFd;
-use crate::utils::buffd::{BufFdError, BUF_SIZE, CMSG_BUF_SIZE, MAX_IN_FD};
-use std::collections::VecDeque;
-use std::mem::MaybeUninit;
-use uapi::{c, Errno, OwnedFd, Pod};
+use {
+    crate::{
+        async_engine::AsyncFd,
+        utils::buffd::{BufFdError, BUF_SIZE, CMSG_BUF_SIZE, MAX_IN_FD},
+    },
+    std::{collections::VecDeque, mem::MaybeUninit},
+    uapi::{c, Errno, OwnedFd, Pod},
+};
 
 pub struct BufFdIn {
     fd: AsyncFd,

src/utils/buffd/buf_out.rs

@@ -1,12 +1,17 @@
-use crate::async_engine::{AsyncFd, Timeout};
-use crate::utils::buffd::{BufFdError, BUF_SIZE, CMSG_BUF_SIZE};
-use futures_util::future::Fuse;
-use futures_util::{select, FutureExt};
-use std::collections::VecDeque;
-use std::mem::MaybeUninit;
-use std::rc::Rc;
-use std::{mem, slice};
-use uapi::{c, Errno, OwnedFd};
+use {
+    crate::{
+        async_engine::{AsyncFd, Timeout},
+        utils::buffd::{BufFdError, BUF_SIZE, CMSG_BUF_SIZE},
+    },
+    futures_util::{future::Fuse, select, FutureExt},
+    std::{
+        collections::VecDeque,
+        mem::{self, MaybeUninit},
+        rc::Rc,
+        slice,
+    },
+    uapi::{c, Errno, OwnedFd},
+};
 
 pub(super) const OUT_BUF_SIZE: usize = 2 * BUF_SIZE;
 

src/utils/buffd/formatter.rs

@@ -1,10 +1,12 @@
-use crate::fixed::Fixed;
-use crate::object::ObjectId;
-use crate::utils::buffd::buf_out::{MsgFds, OutBuffer};
-use std::mem;
-use std::mem::MaybeUninit;
-use std::rc::Rc;
-use uapi::OwnedFd;
+use {
+    crate::{
+        fixed::Fixed,
+        object::ObjectId,
+        utils::buffd::buf_out::{MsgFds, OutBuffer},
+    },
+    std::{mem, mem::MaybeUninit, rc::Rc},
+    uapi::OwnedFd,
+};
 
 pub struct MsgFormatter<'a> {
     buf: &'a mut OutBuffer,

src/utils/buffd/parser.rs

@@ -1,12 +1,10 @@
-use crate::fixed::Fixed;
-use crate::globals::GlobalName;
-use crate::object::ObjectId;
-use crate::utils::buffd::BufFdIn;
-use bstr::{BStr, ByteSlice};
-use std::rc::Rc;
-use std::{mem, ptr};
-use thiserror::Error;
-use uapi::{OwnedFd, Pod};
+use {
+    crate::{fixed::Fixed, globals::GlobalName, object::ObjectId, utils::buffd::BufFdIn},
+    bstr::{BStr, ByteSlice},
+    std::{mem, ptr, rc::Rc},
+    thiserror::Error,
+    uapi::{OwnedFd, Pod},
+};
 
 #[derive(Debug, Error)]
 pub enum MsgParserError {

src/utils/bufio.rs

@@ -1,16 +1,23 @@
-use crate::async_engine::{AsyncError, AsyncFd};
-use crate::utils::oserror::OsError;
-use crate::utils::queue::AsyncQueue;
-use crate::utils::stack::Stack;
-use crate::utils::vec_ext::{UninitVecExt, VecExt};
-use crate::utils::vecstorage::VecStorage;
-use std::collections::VecDeque;
-use std::mem;
-use std::mem::MaybeUninit;
-use std::ptr::NonNull;
-use std::rc::Rc;
-use thiserror::Error;
-use uapi::{c, Errno, MaybeUninitSliceExt, Msghdr, MsghdrMut, OwnedFd};
+use {
+    crate::{
+        async_engine::{AsyncError, AsyncFd},
+        utils::{
+            oserror::OsError,
+            queue::AsyncQueue,
+            stack::Stack,
+            vec_ext::{UninitVecExt, VecExt},
+            vecstorage::VecStorage,
+        },
+    },
+    std::{
+        collections::VecDeque,
+        mem::{self, MaybeUninit},
+        ptr::NonNull,
+        rc::Rc,
+    },
+    thiserror::Error,
+    uapi::{c, Errno, MaybeUninitSliceExt, Msghdr, MsghdrMut, OwnedFd},
+};
 
 #[derive(Debug, Error)]
 pub enum BufIoError {

src/utils/clonecell.rs

@@ -1,10 +1,16 @@
-use crate::utils::linkedlist::NodeRef;
-use crate::utils::ptr_ext::{MutPtrExt, PtrExt};
-use jay_config::keyboard::mods::Modifiers;
-use std::cell::UnsafeCell;
-use std::fmt::{Debug, Formatter};
-use std::mem;
-use std::rc::{Rc, Weak};
+use {
+    crate::utils::{
+        linkedlist::NodeRef,
+        ptr_ext::{MutPtrExt, PtrExt},
+    },
+    jay_config::keyboard::mods::Modifiers,
+    std::{
+        cell::UnsafeCell,
+        fmt::{Debug, Formatter},
+        mem,
+        rc::{Rc, Weak},
+    },
+};
 
 pub struct CloneCell<T: UnsafeCellCloneSafe> {
     data: UnsafeCell<T>,

src/utils/copyhashmap.rs

@@ -1,12 +1,18 @@
-use crate::utils::clonecell::UnsafeCellCloneSafe;
-use crate::utils::ptr_ext::{MutPtrExt, PtrExt};
-use ahash::AHashMap;
-use std::borrow::Borrow;
-use std::cell::UnsafeCell;
-use std::fmt::{Debug, Formatter};
-use std::hash::Hash;
-use std::mem;
-use std::ops::{Deref, DerefMut};
+use {
+    crate::utils::{
+        clonecell::UnsafeCellCloneSafe,
+        ptr_ext::{MutPtrExt, PtrExt},
+    },
+    ahash::AHashMap,
+    std::{
+        borrow::Borrow,
+        cell::UnsafeCell,
+        fmt::{Debug, Formatter},
+        hash::Hash,
+        mem,
+        ops::{Deref, DerefMut},
+    },
+};
 
 pub struct CopyHashMap<K, V> {
     map: UnsafeCell<AHashMap<K, V>>,

src/utils/errorfmt.rs

@@ -1,5 +1,7 @@
-use std::error::Error;
-use std::fmt::{Display, Formatter};
+use std::{
+    error::Error,
+    fmt::{Display, Formatter},
+};
 
 pub struct ErrorFmt<E>(pub E);
 

src/utils/fdcloser.rs

@@ -1,7 +1,11 @@
-use std::mem;
-use std::rc::Rc;
-use std::sync::{Arc, Condvar, Mutex};
-use uapi::OwnedFd;
+use {
+    std::{
+        mem,
+        rc::Rc,
+        sync::{Arc, Condvar, Mutex},
+    },
+    uapi::OwnedFd,
+};
 
 pub struct FdCloser {
     fds: Mutex<Vec<OwnedFd>>,

src/utils/linkedlist.rs

@@ -1,10 +1,13 @@
-use crate::utils::numcell::NumCell;
-use crate::utils::ptr_ext::PtrExt;
-use std::cell::Cell;
-use std::fmt::{Debug, Formatter};
-use std::mem;
-use std::ops::Deref;
-use std::ptr::NonNull;
+use {
+    crate::utils::{numcell::NumCell, ptr_ext::PtrExt},
+    std::{
+        cell::Cell,
+        fmt::{Debug, Formatter},
+        mem,
+        ops::Deref,
+        ptr::NonNull,
+    },
+};
 
 pub struct LinkedList<T> {
     root: LinkedNode<T>,
@@ -52,6 +55,7 @@ impl<T> LinkedList<T> {
         }
     }
 
+    #[allow(dead_code)]
     pub fn is_empty(&self) -> bool {
         self.last().is_none()
     }

src/utils/nonblock.rs

@@ -1,5 +1,4 @@
-use crate::utils::oserror::OsError;
-use uapi::c;
+use {crate::utils::oserror::OsError, uapi::c};
 
 pub fn set_nonblock(fd: c::c_int) -> Result<(), OsError> {
     let fl = uapi::fcntl_getfl(fd)?;

src/utils/numcell.rs

@@ -1,6 +1,8 @@
-use std::cell::Cell;
-use std::fmt::{Debug, Formatter};
-use std::ops::{Add, BitAnd, BitOr, Sub};
+use std::{
+    cell::Cell,
+    fmt::{Debug, Formatter},
+    ops::{Add, BitAnd, BitOr, Sub},
+};
 
 #[derive(Default)]
 pub struct NumCell<T> {

src/utils/oserror.rs

@@ -1,8 +1,11 @@
-use once_cell::sync::Lazy;
-use std::error::Error;
-use std::fmt::{Display, Formatter};
-use uapi::c::c_int;
-use uapi::{c, Errno};
+use {
+    once_cell::sync::Lazy,
+    std::{
+        error::Error,
+        fmt::{Display, Formatter},
+    },
+    uapi::{c, c::c_int, Errno},
+};
 
 static ERRORS: Lazy<&'static [Option<&'static str>]> = Lazy::new(|| {
     static MSGS: &[(c::c_int, &str)] = &[

src/utils/queue.rs

@@ -1,9 +1,11 @@
-use std::cell::{Cell, RefCell};
-use std::collections::VecDeque;
-use std::future::Future;
-use std::mem;
-use std::pin::Pin;
-use std::task::{Context, Poll, Waker};
+use std::{
+    cell::{Cell, RefCell},
+    collections::VecDeque,
+    future::Future,
+    mem,
+    pin::Pin,
+    task::{Context, Poll, Waker},
+};
 
 pub struct AsyncQueue<T> {
     data: RefCell<VecDeque<T>>,

src/utils/run_toplevel.rs

@@ -1,6 +1,10 @@
-use crate::async_engine::{AsyncEngine, SpawnedFuture};
-use crate::utils::queue::AsyncQueue;
-use std::rc::Rc;
+use {
+    crate::{
+        async_engine::{AsyncEngine, SpawnedFuture},
+        utils::queue::AsyncQueue,
+    },
+    std::rc::Rc,
+};
 
 pub struct RunToplevelFuture {
     _future: SpawnedFuture<()>,

src/utils/smallmap.rs

@@ -1,9 +1,15 @@
-use crate::utils::clonecell::UnsafeCellCloneSafe;
-use crate::utils::ptr_ext::{MutPtrExt, PtrExt};
-use smallvec::SmallVec;
-use std::cell::UnsafeCell;
-use std::fmt::{Debug, Formatter};
-use std::mem;
+use {
+    crate::utils::{
+        clonecell::UnsafeCellCloneSafe,
+        ptr_ext::{MutPtrExt, PtrExt},
+    },
+    smallvec::SmallVec,
+    std::{
+        cell::UnsafeCell,
+        fmt::{Debug, Formatter},
+        mem,
+    },
+};
 
 pub struct SmallMap<K, V, const N: usize> {
     m: UnsafeCell<SmallVec<[(K, V); N]>>,

src/utils/stack.rs

@@ -1,5 +1,7 @@
-use crate::utils::ptr_ext::{MutPtrExt, PtrExt};
-use std::cell::UnsafeCell;
+use {
+    crate::utils::ptr_ext::{MutPtrExt, PtrExt},
+    std::cell::UnsafeCell,
+};
 
 pub struct Stack<T> {
     vec: UnsafeCell<Vec<T>>,

src/utils/syncqueue.rs

@@ -1,7 +1,7 @@
-use crate::utils::ptr_ext::MutPtrExt;
-use std::cell::UnsafeCell;
-use std::collections::VecDeque;
-use std::mem;
+use {
+    crate::utils::ptr_ext::MutPtrExt,
+    std::{cell::UnsafeCell, collections::VecDeque, mem},
+};
 
 #[derive(Debug)]
 pub struct SyncQueue<T> {

src/utils/tri.rs

@@ -1,7 +1,9 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 pub trait Try: Sized {
     fn tri<F>(f: F) -> Result<(), Self>

src/utils/vasprintf.rs

@@ -1,7 +1,11 @@
-use std::ffi::{CStr, VaList};
-use std::ops::Deref;
-use std::ptr;
-use uapi::c;
+use {
+    std::{
+        ffi::{CStr, VaList},
+        ops::Deref,
+        ptr,
+    },
+    uapi::c,
+};
 
 extern "C" {
     fn vasprintf(strp: *mut *mut c::c_char, fmt: *const c::c_char, ap: VaList) -> c::c_int;

src/utils/vec_ext.rs

@@ -1,6 +1,4 @@
-use std::mem::MaybeUninit;
-use std::ops::Range;
-use std::slice;
+use std::{mem::MaybeUninit, ops::Range, slice};
 
 pub trait VecExt<T> {
     fn split_at_spare_mut_ext(&mut self) -> (&mut [T], &mut [MaybeUninit<T>]);

src/utils/vecstorage.rs

@@ -1,5 +1,7 @@
-use std::mem::ManuallyDrop;
-use std::ops::{Deref, DerefMut};
+use std::{
+    mem::ManuallyDrop,
+    ops::{Deref, DerefMut},
+};
 
 pub struct VecStorage<T> {
     ptr: *mut T,