Merge pull request #5 from structured-world/fix/#1-clippy-warnings

fix: resolve all clippy warnings for strict -D warnings CI

Author: polaz

clippy.toml

@@ -0,0 +1 @@
+allowed-duplicate-crates = ["hashbrown"]

src/builder.rs

@@ -183,6 +183,7 @@ impl<O: Openable> Builder<O> {
     /// #
     /// # Ok::<_, fjall::Error>(())
     /// ```
+    #[must_use]
     pub fn with_compaction_filter_factories(mut self, f: CompactionFilterAssigner) -> Self {
         self.inner.compaction_filter_factory_assigner = Some(f);
         self

src/db.rs

@@ -85,11 +85,19 @@ impl Drop for DatabaseInner {
 
         // IMPORTANT: Break cyclic Arcs
         self.supervisor.flush_manager.clear();
+        #[expect(
+            clippy::expect_used,
+            reason = "Drop impl cannot propagate errors from poisoned locks"
+        )]
         self.supervisor
             .keyspaces
             .write()
             .expect("lock is poisoned")
             .clear();
+        #[expect(
+            clippy::expect_used,
+            reason = "Drop impl cannot propagate errors from poisoned locks"
+        )]
         self.supervisor
             .journal_manager
             .write()
@@ -277,7 +285,12 @@ impl Database {
     /// # Ok::<(), fjall::Error>(())
     /// ```
     #[must_use]
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "panics only if internal RwLock is poisoned"
+    )]
     pub fn journal_count(&self) -> usize {
+        #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
         self.supervisor
             .journal_manager
             .read()
@@ -288,6 +301,7 @@ impl Database {
     /// Returns the disk space usage of the journal.
     #[doc(hidden)]
     pub fn journal_disk_space(&self) -> crate::Result<u64> {
+        #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
         Ok(self.supervisor.journal.get_writer().len()?
             + self
                 .supervisor
@@ -311,9 +325,18 @@ impl Database {
     /// #
     /// # Ok::<(), fjall::Error>(())
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if an IO error occurs.
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "panics only if internal RwLock is poisoned"
+    )]
     pub fn disk_space(&self) -> crate::Result<u64> {
         let journal_size = self.journal_disk_space()?;
 
+        #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
         let keyspaces_size = self
             .supervisor
             .keyspaces
@@ -349,7 +372,7 @@ impl Database {
     ///
     /// # Errors
     ///
-    /// Returns error, if an IO error occurred.
+    /// Returns an error if an IO error occurs.
     pub fn persist(&self, mode: PersistMode) -> crate::Result<()> {
         if self.is_poisoned.load(std::sync::atomic::Ordering::Relaxed) {
             return Err(crate::Error::Poisoned);
@@ -385,7 +408,7 @@ impl Database {
     ///
     /// # Errors
     ///
-    /// Returns error, if an IO error occurred.
+    /// Returns an error if an IO error occurs.
     pub fn open(config: Config) -> crate::Result<Self> {
         log::debug!(
             "cache capacity={}MiB",
@@ -443,7 +466,7 @@ impl Database {
     ///
     /// # Errors
     ///
-    /// Returns error, if an IO error occurred.
+    /// Returns an error if an IO error occurs.
     ///
     /// # Panics
     ///
@@ -455,6 +478,7 @@ impl Database {
     ) -> crate::Result<Keyspace> {
         assert!(is_valid_keyspace_name(name));
 
+        #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
         let keyspaces = self.supervisor.keyspaces.write().expect("lock is poisoned");
 
         Ok(if let Some(keyspace) = keyspaces.get(name) {
@@ -490,7 +514,12 @@ impl Database {
 
     /// Returns the number of keyspaces.
     #[must_use]
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "panics only if internal RwLock is poisoned"
+    )]
     pub fn keyspace_count(&self) -> usize {
+        #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
         self.supervisor
             .keyspaces
             .read()
@@ -500,7 +529,12 @@ impl Database {
 
     /// Gets a list of all keyspace names in the database.
     #[must_use]
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "panics only if internal RwLock is poisoned"
+    )]
     pub fn list_keyspace_names(&self) -> Vec<KeyspaceKey> {
+        #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
         self.supervisor
             .keyspaces
             .read()
@@ -771,6 +805,10 @@ impl Database {
 
         db.supervisor.snapshot_tracker.gc();
 
+        #[expect(
+            clippy::expect_used,
+            reason = "poisoned lock during recovery is unrecoverable"
+        )]
         for keyspace in db
             .supervisor
             .keyspaces

src/db_config.rs

@@ -9,7 +9,9 @@ use std::{
     sync::Arc,
 };
 
-pub(crate) type CompactionFilterAssigner =
+// NOTE: This type is used crate-internally. The module is private so `pub` here
+// is effectively `pub(crate)`. Using `pub` avoids clippy::redundant_pub_crate.
+pub type CompactionFilterAssigner =
     Arc<dyn Fn(&str) -> Option<Arc<dyn lsm_tree::compaction::filter::Factory>> + Send + Sync>;
 
 /// Global database configuration

src/journal/entry.rs

@@ -196,7 +196,13 @@ impl Entry {
                         let compressed_value =
                             Slice::from_reader(reader, on_disk_value_len as usize)?;
 
-                        #[warn(unsafe_code)]
+                        #[expect(
+                            unsafe_code,
+                            reason = "unzeroed buffer for LZ4 decompression performance"
+                        )]
+                        // SAFETY: decompress_into writes exactly value_len bytes on success
+                        // (validated by the size check below). The buffer is fully initialized
+                        // before freeze() is called.
                         let mut value = unsafe { Slice::builder_unzeroed(value_len as usize) };
 
                         let size = lz4_flex::decompress_into(&compressed_value, &mut value)

src/journal/error.rs

@@ -5,6 +5,7 @@
 /// Recovery mode to use
 ///
 /// Based on `RocksDB`'s WAL Recovery Modes: <https://github.com/facebook/rocksdb/wiki/WAL-Recovery-Modes>
+#[expect(dead_code, reason = "reserved for future WAL recovery mode selection")]
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 #[non_exhaustive]
 pub enum RecoveryMode {

src/journal/mod.rs

@@ -56,6 +56,7 @@ impl Drop for Journal {
 impl Journal {
     pub fn with_compression(self, comp: CompressionType, threshold: usize) -> Self {
         {
+            #[expect(clippy::expect_used, reason = "poisoned lock is unrecoverable")]
             let mut writer = self.writer.lock().expect("lock is poisoned");
             writer.set_compression(comp, threshold);
         }
@@ -72,6 +73,10 @@ impl Journal {
         let path = path.as_ref();
         log::trace!("Creating new journal at {}", path.display());
 
+        #[expect(
+            clippy::expect_used,
+            reason = "journal path always has a parent directory"
+        )]
         let folder = path.parent().expect("parent should exist");
 
         std::fs::create_dir_all(folder).inspect_err(|e| {

src/journal/writer.rs

@@ -82,12 +82,20 @@ impl Writer {
 
         let prev_path = self.path.clone();
 
+        #[expect(
+            clippy::expect_used,
+            reason = "journal path always has a parent directory"
+        )]
         let folder = self
             .path
             .parent()
             .expect("should have parent")
             .to_path_buf();
 
+        #[expect(
+            clippy::expect_used,
+            reason = "journal file names are always valid .jnl files"
+        )]
         let Some(basename) = self
             .path
             .file_name()

src/keyspace/config/filter.rs

@@ -15,6 +15,7 @@ impl EncodeConfig for crate::config::FilterPolicy {
         v.write_u8(self.len() as u8)
             .expect("cannot fail writing into a vec");
 
+        #[expect(clippy::expect_used, reason = "writing into a Vec cannot fail")]
         for item in self.iter() {
             match item {
                 crate::config::FilterPolicyEntry::None => {

src/keyspace/config/pinning.rs

@@ -25,12 +25,12 @@ impl EncodeConfig for crate::config::PinningPolicy {
 
 impl DecodeConfig for crate::config::PinningPolicy {
     fn decode(mut bytes: &[u8]) -> crate::Result<Self> {
-        let len = bytes.read_u8().expect("cannot fail");
+        let len = bytes.read_u8()?;
 
         let mut v = vec![];
 
         for _ in 0..len {
-            let b = bytes.read_u8().expect("cannot fail");
+            let b = bytes.read_u8()?;
             v.push(b == 1);
         }