cargo +nightly fmt

Author: anacrolix

build.rs

@@ -1,4 +1,4 @@
 fn main() {
     // We have a custom "loom" cfg that Rust warns about since 1.80.
     println!("cargo::rustc-check-cfg=cfg(loom)");
-}
+}

src/c_api/ext_fns/handle.rs

@@ -217,10 +217,5 @@ pub extern "C" fn possum_handle_delete_prefix(
     prefix: PossumBuf,
 ) -> PossumError {
     let handle = unsafe { &mut *handle };
-    with_residual(|| {
-        handle
-            .read()
-            .unwrap()
-            .delete_prefix(prefix.as_ref())
-    })
+    with_residual(|| handle.read().unwrap().delete_prefix(prefix.as_ref()))
 }

src/c_api/types.rs

@@ -1,12 +1,11 @@
 mod value;
 
-use super::*;
-
 use std::ffi::c_char;
 
 use libc::size_t;
 pub(crate) use value::*;
 
+use super::*;
 use crate::{BatchWriter, Handle, ValueWriter};
 
 pub(crate) type PossumOffset = u64;

src/concurrency/mod.rs

@@ -31,22 +31,22 @@ where
 
 #[cfg(feature = "shuttle")]
 pub(crate) fn run_blocking<F, R>(f: F) -> R
-    where
-        F: FnOnce() -> R + Send,
-        R: Send,
+where
+    F: FnOnce() -> R + Send,
+    R: Send,
 {
     use std::sync::mpsc;
     let (sender, receiver) = mpsc::channel();
     let tx_thread = std::thread::scope(|scope| {
-        scope.spawn(||{
+        scope.spawn(|| {
             let res = f();
             sender.send(res).unwrap();
         });
         loop {
             shuttle::thread::yield_now();
             match receiver.try_recv() {
                 Err(mpsc::TryRecvError::Empty) => continue,
-                default => return default.unwrap()
+                default => return default.unwrap(),
             }
         }
     });

src/concurrency/sync.rs

@@ -1,17 +1,16 @@
-use crate::StableDeref;
 use std::ops::{Deref, DerefMut};
-
-#[cfg(feature = "shuttle")]
-use shuttle::sync;
 #[cfg(not(feature = "shuttle"))]
 use std::sync;
-
-use sync::Mutex as InnerMutex;
-use sync::MutexGuard as InnerMutexGuard;
-pub use sync::*;
 // These types work in any sync context.
 use std::sync::{LockResult, PoisonError};
 
+#[cfg(feature = "shuttle")]
+use shuttle::sync;
+pub use sync::*;
+use sync::{Mutex as InnerMutex, MutexGuard as InnerMutexGuard};
+
+use crate::StableDeref;
+
 // We need to wrap the real mutex guard in use, so we can implement StableDeref on it.
 pub struct MutexGuard<'a, T>(InnerMutexGuard<'a, T>);
 

src/dir.rs

@@ -40,11 +40,11 @@ impl Dir {
                     Err(err) if CloneFileError::is_unsupported(&err) => {
                         warn!(?err, "clonefile unsupported");
                         false
-                    },
+                    }
                     Err(err) => {
                         error!(?err);
-                        return Err(err).context("testing clonefile")
-                    },
+                        return Err(err).context("testing clonefile");
+                    }
                 }
             }
         };

src/handle.rs

@@ -1,7 +1,7 @@
-use super::*;
-
 use rusqlite::{TransactionBehavior, TransactionState};
 
+use super::*;
+
 #[derive(Default, Debug)]
 #[repr(C)]
 pub struct Limits {

src/lib.rs

@@ -69,9 +69,9 @@ use reader::Reader;
 
 // Concurrency related stuff that's replaced by loom or shuttle.
 pub mod concurrency;
-use self::concurrency::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard};
 use concurrency::*;
 
+use self::concurrency::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard};
 use crate::handle::WithHandle;
 
 /// Type to be exposed eventually from the lib instead of anyhow. Should be useful for the C API.

src/sys/unix.rs

@@ -2,10 +2,10 @@ use std::fs::File;
 use std::io;
 use std::path::Path;
 
-use crate::sys::{DirMeta, FileSystemFlags};
 pub(crate) use nix::errno::errno;
 
 use crate::env::emulate_freebsd;
+use crate::sys::{DirMeta, FileSystemFlags};
 
 pub fn path_disk_allocation(path: &Path) -> std::io::Result<u64> {
     let metadata = std::fs::metadata(path)?;

src/testing.rs

@@ -1,7 +1,7 @@
 pub mod torrent_storage;
 
 use std::hash::Hasher;
-use std::io::{BufReader, copy, SeekFrom, Write};
+use std::io::{copy, BufReader, SeekFrom, Write};
 
 use anyhow::{ensure, Result};
 use rand::Rng;

src/tests.rs

@@ -1,11 +1,11 @@
-use crate::concurrency::sync::Barrier;
 use std::time::*;
 
 use anyhow::Result;
 use rusqlite::TransactionState;
 
 use self::test;
 use super::*;
+use crate::concurrency::sync::Barrier;
 use crate::testing::*;
 
 #[test]

tests/simple_tests.rs

@@ -15,6 +15,7 @@ use std::time::{Duration, Instant};
 use anyhow::{anyhow, bail, Context, Result};
 use fdlimit::raise_fd_limit;
 use itertools::Itertools;
+use possum::concurrency::thread;
 use possum::testing::*;
 use possum::walk::{walk_dir, EntryType};
 use possum::Error::NoSuchKey;
@@ -23,12 +24,10 @@ use rand::distributions::uniform::{UniformDuration, UniformSampler};
 use rand::{thread_rng, RngCore, SeedableRng};
 use tempfile::tempdir;
 use test_log::test;
+use thread::sleep;
 use tracing::*;
 use walk::Entry as WalkEntry;
 
-use possum::concurrency::thread;
-use thread::sleep;
-
 #[test]
 fn rename_key() -> Result<()> {
     check_concurrency(