more linting (#647)

Author: Stephan Dilly

asyncgit/src/commit_files.rs

@@ -35,11 +35,8 @@ impl AsyncCommitFiles {
     ) -> Result<Option<(CommitId, ResultType)>> {
         let c = self.current.lock()?;
 
-        if let Some(c) = c.as_ref() {
-            Ok(Some((c.0, c.1.clone())))
-        } else {
-            Ok(None)
-        }
+        c.as_ref()
+            .map_or(Ok(None), |c| Ok(Some((c.0, c.1.clone()))))
     }
 
     ///
@@ -71,7 +68,7 @@ impl AsyncCommitFiles {
         self.pending.fetch_add(1, Ordering::Relaxed);
 
         rayon_core::spawn(move || {
-            Self::fetch_helper(id, arc_current)
+            Self::fetch_helper(id, &arc_current)
                 .expect("failed to fetch");
 
             arc_pending.fetch_sub(1, Ordering::Relaxed);
@@ -86,7 +83,7 @@ impl AsyncCommitFiles {
 
     fn fetch_helper(
         id: CommitId,
-        arc_current: Arc<
+        arc_current: &Arc<
             Mutex<Option<Request<CommitId, ResultType>>>,
         >,
     ) -> Result<()> {

asyncgit/src/diff.rs

@@ -110,10 +110,10 @@ impl AsyncDiff {
         self.pending.fetch_add(1, Ordering::Relaxed);
 
         rayon_core::spawn(move || {
-            let notify = AsyncDiff::get_diff_helper(
+            let notify = Self::get_diff_helper(
                 params,
-                arc_last,
-                arc_current,
+                &arc_last,
+                &arc_current,
                 hash,
             );
 
@@ -141,18 +141,18 @@ impl AsyncDiff {
 
     fn get_diff_helper(
         params: DiffParams,
-        arc_last: Arc<
+        arc_last: &Arc<
             Mutex<Option<LastResult<DiffParams, FileDiff>>>,
         >,
-        arc_current: Arc<Mutex<Request<u64, FileDiff>>>,
+        arc_current: &Arc<Mutex<Request<u64, FileDiff>>>,
         hash: u64,
     ) -> Result<bool> {
         let res = match params.diff_type {
             DiffType::Stage => {
-                sync::diff::get_diff(CWD, params.path.clone(), true)?
+                sync::diff::get_diff(CWD, &params.path, true)?
             }
             DiffType::WorkDir => {
-                sync::diff::get_diff(CWD, params.path.clone(), false)?
+                sync::diff::get_diff(CWD, &params.path, false)?
             }
             DiffType::Commit(id) => sync::diff::get_diff_commit(
                 CWD,

asyncgit/src/error.rs

@@ -38,6 +38,6 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 impl<T> From<std::sync::PoisonError<T>> for Error {
     fn from(error: std::sync::PoisonError<T>) -> Self {
-        Error::Generic(format!("poison error: {}", error))
+        Self::Generic(format!("poison error: {}", error))
     }
 }

asyncgit/src/fetch.rs

@@ -74,7 +74,7 @@ impl AsyncFetch {
         }
 
         self.set_request(&params)?;
-        RemoteProgress::set_progress(self.progress.clone(), None)?;
+        RemoteProgress::set_progress(&self.progress, None)?;
 
         let arc_state = Arc::clone(&self.state);
         let arc_res = Arc::clone(&self.last_result);
@@ -104,9 +104,9 @@ impl AsyncFetch {
 
             handle.join().expect("joining thread failed");
 
-            Self::set_result(arc_res, res).expect("result error");
+            Self::set_result(&arc_res, res).expect("result error");
 
-            Self::clear_request(arc_state).expect("clear error");
+            Self::clear_request(&arc_state).expect("clear error");
 
             sender
                 .send(AsyncNotification::Fetch)
@@ -131,7 +131,7 @@ impl AsyncFetch {
     }
 
     fn clear_request(
-        state: Arc<Mutex<Option<FetchState>>>,
+        state: &Arc<Mutex<Option<FetchState>>>,
     ) -> Result<()> {
         let mut state = state.lock()?;
 
@@ -141,7 +141,7 @@ impl AsyncFetch {
     }
 
     fn set_result(
-        arc_result: Arc<Mutex<Option<(usize, String)>>>,
+        arc_result: &Arc<Mutex<Option<(usize, String)>>>,
         res: Result<usize>,
     ) -> Result<()> {
         let mut last_res = arc_result.lock()?;

asyncgit/src/lib.rs

@@ -8,29 +8,23 @@
 #![deny(clippy::all)]
 #![deny(clippy::cargo)]
 #![deny(clippy::pedantic)]
-//TODO:
-// #![deny(clippy::nursery)]
+#![deny(clippy::nursery)]
 #![deny(clippy::unwrap_used)]
 #![deny(clippy::panic)]
 #![deny(clippy::perf)]
 #![deny(clippy::match_like_matches_macro)]
 #![deny(clippy::needless_update)]
 #![allow(clippy::module_name_repetitions)]
+#![allow(clippy::must_use_candidate)]
 //TODO: get this in someday since expect still leads us to crashes sometimes
 // #![deny(clippy::expect_used)]
 //TODO:
-#![allow(clippy::needless_pass_by_value)]
-#![allow(clippy::must_use_candidate)]
 #![allow(clippy::missing_errors_doc)]
-#![allow(clippy::map_unwrap_or)]
-#![allow(clippy::option_if_let_else)]
-#![allow(clippy::manual_ok_or)]
-#![allow(clippy::doc_markdown)]
+#![allow(clippy::too_many_lines)]
 #![allow(clippy::cast_possible_wrap)]
 #![allow(clippy::cast_sign_loss)]
 #![allow(clippy::cast_possible_truncation)]
 #![allow(clippy::cast_precision_loss)]
-#![allow(clippy::too_many_lines)]
 
 pub mod cached;
 mod commit_files;

asyncgit/src/progress.rs

@@ -18,11 +18,11 @@ impl ProgressPercent {
         Self { progress }
     }
     ///
-    pub fn empty() -> Self {
+    pub const fn empty() -> Self {
         Self { progress: 0 }
     }
     ///
-    pub fn full() -> Self {
+    pub const fn full() -> Self {
         Self { progress: 100 }
     }
 }

asyncgit/src/push.rs

@@ -76,7 +76,7 @@ impl AsyncPush {
         }
 
         self.set_request(&params)?;
-        RemoteProgress::set_progress(self.progress.clone(), None)?;
+        RemoteProgress::set_progress(&self.progress, None)?;
 
         let arc_state = Arc::clone(&self.state);
         let arc_res = Arc::clone(&self.last_result);
@@ -108,9 +108,9 @@ impl AsyncPush {
 
             handle.join().expect("joining thread failed");
 
-            Self::set_result(arc_res, res).expect("result error");
+            Self::set_result(&arc_res, res).expect("result error");
 
-            Self::clear_request(arc_state).expect("clear error");
+            Self::clear_request(&arc_state).expect("clear error");
 
             sender
                 .send(AsyncNotification::Push)
@@ -135,7 +135,7 @@ impl AsyncPush {
     }
 
     fn clear_request(
-        state: Arc<Mutex<Option<PushState>>>,
+        state: &Arc<Mutex<Option<PushState>>>,
     ) -> Result<()> {
         let mut state = state.lock()?;
 
@@ -145,7 +145,7 @@ impl AsyncPush {
     }
 
     fn set_result(
-        arc_result: Arc<Mutex<Option<String>>>,
+        arc_result: &Arc<Mutex<Option<String>>>,
         res: Result<()>,
     ) -> Result<()> {
         let mut last_res = arc_result.lock()?;

asyncgit/src/push_tags.rs

@@ -72,7 +72,7 @@ impl AsyncPushTags {
         }
 
         self.set_request(&params)?;
-        RemoteProgress::set_progress(self.progress.clone(), None)?;
+        RemoteProgress::set_progress(&self.progress, None)?;
 
         let arc_state = Arc::clone(&self.state);
         let arc_res = Arc::clone(&self.last_result);
@@ -98,9 +98,9 @@ impl AsyncPushTags {
 
             handle.join().expect("joining thread failed");
 
-            Self::set_result(arc_res, res).expect("result error");
+            Self::set_result(&arc_res, res).expect("result error");
 
-            Self::clear_request(arc_state).expect("clear error");
+            Self::clear_request(&arc_state).expect("clear error");
 
             sender
                 .send(AsyncNotification::PushTags)
@@ -125,7 +125,7 @@ impl AsyncPushTags {
     }
 
     fn clear_request(
-        state: Arc<Mutex<Option<PushState>>>,
+        state: &Arc<Mutex<Option<PushState>>>,
     ) -> Result<()> {
         let mut state = state.lock()?;
 
@@ -135,7 +135,7 @@ impl AsyncPushTags {
     }
 
     fn set_result(
-        arc_result: Arc<Mutex<Option<String>>>,
+        arc_result: &Arc<Mutex<Option<String>>>,
         res: Result<()>,
     ) -> Result<()> {
         let mut last_res = arc_result.lock()?;

asyncgit/src/remote_progress.rs

@@ -52,12 +52,12 @@ impl RemoteProgress {
     }
 
     ///
-    pub fn get_progress_percent(&self) -> u8 {
+    pub const fn get_progress_percent(&self) -> u8 {
         self.progress.progress
     }
 
     pub(crate) fn set_progress<T>(
-        progress: Arc<Mutex<Option<T>>>,
+        progress: &Arc<Mutex<Option<T>>>,
         state: Option<T>,
     ) -> Result<()> {
         let mut progress = progress.lock()?;
@@ -81,7 +81,7 @@ impl RemoteProgress {
             match incoming {
                 Ok(update) => {
                     Self::set_progress(
-                        progress.clone(),
+                        &progress,
                         Some(update.clone()),
                     )
                     .expect("set progress failed");
@@ -116,26 +116,22 @@ impl From<ProgressNotification> for RemoteProgress {
                 current,
                 total,
             } => match stage {
-                PackBuilderStage::AddingObjects => {
-                    RemoteProgress::new(
-                        RemoteProgressState::PackingAddingObject,
-                        current,
-                        total,
-                    )
-                }
-                PackBuilderStage::Deltafication => {
-                    RemoteProgress::new(
-                        RemoteProgressState::PackingDeltafiction,
-                        current,
-                        total,
-                    )
-                }
+                PackBuilderStage::AddingObjects => Self::new(
+                    RemoteProgressState::PackingAddingObject,
+                    current,
+                    total,
+                ),
+                PackBuilderStage::Deltafication => Self::new(
+                    RemoteProgressState::PackingDeltafiction,
+                    current,
+                    total,
+                ),
             },
             ProgressNotification::PushTransfer {
                 current,
                 total,
                 ..
-            } => RemoteProgress::new(
+            } => Self::new(
                 RemoteProgressState::Pushing,
                 current,
                 total,
@@ -144,12 +140,12 @@ impl From<ProgressNotification> for RemoteProgress {
                 objects,
                 total_objects,
                 ..
-            } => RemoteProgress::new(
+            } => Self::new(
                 RemoteProgressState::Transfer,
                 objects,
                 total_objects,
             ),
-            _ => RemoteProgress::new(RemoteProgressState::Done, 1, 1),
+            _ => Self::new(RemoteProgressState::Done, 1, 1),
         }
     }
 }

asyncgit/src/revlog.rs

@@ -121,9 +121,9 @@ impl AsyncLog {
         rayon_core::spawn(move || {
             scope_time!("async::revlog");
 
-            AsyncLog::fetch_helper(
-                arc_current,
-                arc_background,
+            Self::fetch_helper(
+                &arc_current,
+                &arc_background,
                 &sender,
             )
             .expect("failed to fetch");
@@ -137,8 +137,8 @@ impl AsyncLog {
     }
 
     fn fetch_helper(
-        arc_current: Arc<Mutex<Vec<CommitId>>>,
-        arc_background: Arc<AtomicBool>,
+        arc_current: &Arc<Mutex<Vec<CommitId>>>,
+        arc_background: &Arc<AtomicBool>,
         sender: &Sender<AsyncNotification>,
     ) -> Result<()> {
         let mut entries = Vec::with_capacity(LIMIT_COUNT);
@@ -157,7 +157,7 @@ impl AsyncLog {
             if res_is_err || entries.len() <= 1 {
                 break;
             }
-            Self::notify(&sender);
+            Self::notify(sender);
 
             let sleep_duration =
                 if arc_background.load(Ordering::Relaxed) {