[Clippy] Address most clippy issues in production code

src/apply.rs

@@ -1,9 +1,6 @@
 //! git_apply support
 //! see original: <https://github.com/libgit2/libgit2/blob/master/include/git2/apply.h>
 
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::new_without_default)]
-
 use crate::{panic, raw, util::Binding, DiffDelta, DiffHunk};
 use libc::c_int;
 use std::{ffi::c_void, mem};
@@ -146,11 +143,23 @@ impl<'cb> ApplyOptions<'cb> {
     }
 
     /// Pointer to a raw git_stash_apply_options
+    ///
+    /// # Safety
+    ///
+    /// The provided pointer must not be used to manipulate the options, and
+    /// must not outlive the [`ApplyOptions`] instance.
     pub unsafe fn raw(&mut self) -> *const raw::git_apply_options {
         &self.raw as *const _
     }
 }
 
+impl<'cb> Default for ApplyOptions<'cb> {
+    /// Creates a new set of empty options (zeroed).
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[cfg(test)]
 #[allow(clippy::needless_borrows_for_generic_args)]
 mod tests {

src/blame.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::redundant_closure)]
-
 use crate::util::{self, Binding};
 use crate::{raw, signature, Error, ErrorClass, ErrorCode, Oid, Repository, Signature};
 use libc::c_char;
@@ -222,7 +220,7 @@ impl<'blame> BlameHunk<'blame> {
     /// `Ok(None)` may be returned if there is no summary.
     pub fn summary(&self) -> Result<Option<&str>, Error> {
         match self.summary_bytes() {
-            Some(sb) => str::from_utf8(sb).map(|s| Some(s)).map_err(|e| e.into()),
+            Some(sb) => str::from_utf8(sb).map(Some).map_err(|e| e.into()),
             None => Ok(None),
         }
     }

src/blob.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::io_other_error)]
-
 use std::io;
 use std::marker;
 use std::mem;
@@ -139,12 +137,12 @@ impl<'repo> io::Write for BlobWriter<'repo> {
         if let Some(f) = write_cb {
             let res = f(self.raw, buf.as_ptr() as *const _, buf.len());
             if res < 0 {
-                Err(io::Error::new(io::ErrorKind::Other, "Write error"))
+                Err(io::Error::other("Write error"))
             } else {
                 Ok(buf.len())
             }
         } else {
-            Err(io::Error::new(io::ErrorKind::Other, "no write callback"))
+            Err(io::Error::other("no write callback"))
         }
     }
     fn flush(&mut self) -> io::Result<()> {

src/branch.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::missing_safety_doc)]
-
 use std::ffi::CString;
 use std::marker;
 use std::ptr;
@@ -129,8 +127,11 @@ impl<'repo> Branch<'repo> {
 impl<'repo> Branches<'repo> {
     /// Creates a new iterator from the raw pointer given.
     ///
+    /// # Safety
+    ///
     /// This function is unsafe as it is not guaranteed that `raw` is a valid
-    /// pointer.
+    /// pointer. The caller must ensure that `raw` is a valid pointer and lives
+    /// as long as the [`Branches`] object.
     pub unsafe fn from_raw(raw: *mut raw::git_branch_iterator) -> Branches<'repo> {
         Branches {
             raw,

src/buf.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::explicit_auto_deref)]
-
 use std::ops::{Deref, DerefMut};
 use std::ptr;
 use std::slice;
@@ -38,7 +36,7 @@ impl Buf {
 
     /// Attempt to view this buffer as a string slice.
     pub fn as_str(&self) -> Result<&str, Error> {
-        str::from_utf8(&**self).map_err(|e| e.into())
+        str::from_utf8(self).map_err(|e| e.into())
     }
 }
 
@@ -78,6 +76,7 @@ impl Drop for Buf {
 }
 
 #[test]
+#[allow(clippy::explicit_auto_deref)]
 fn empty_buf() {
     let mut buf = Buf::new();
     let x: &[u8] = &*buf;

src/build.rs

@@ -1,8 +1,5 @@
 //! Builder-pattern objects for configuration various git operations.
 
-#![allow(clippy::manual_non_exhaustive)]
-#![allow(clippy::missing_safety_doc)]
-
 use libc::{c_char, c_int, c_uint, c_void, size_t};
 use std::ffi::{CStr, CString};
 use std::mem;
@@ -128,6 +125,7 @@ impl<'cb> Default for RepoBuilder<'cb> {
 
 /// Options that can be passed to `RepoBuilder::clone_local`.
 #[derive(Clone, Copy)]
+#[non_exhaustive]
 pub enum CloneLocal {
     /// Auto-detect (default)
     ///
@@ -143,9 +141,6 @@ pub enum CloneLocal {
 
     /// Bypass the git-aware transport, but don't try to use hardlinks.
     NoLinks = raw::GIT_CLONE_LOCAL_NO_LINKS as isize,
-
-    #[doc(hidden)]
-    __Nonexhaustive = 0xff,
 }
 
 impl<'cb> RepoBuilder<'cb> {
@@ -593,8 +588,14 @@ impl<'cb> CheckoutBuilder<'cb> {
 
     /// Configure a raw checkout options based on this configuration.
     ///
+    /// # Safety
+    ///
     /// This method is unsafe as there is no guarantee that this structure will
-    /// outlive the provided checkout options.
+    /// outlive the provided checkout options. The caller must ensure that
+    /// `opts` does not outlive the [`CheckoutBuilder`], and also that for any
+    /// fields configured in the `CheckoutBuilder` that are provided to the
+    /// `opts` as pointers, those pointers are not used if the original
+    /// references held in the `CheckoutBuilder` are dropped.
     pub unsafe fn configure(&mut self, opts: &mut raw::git_checkout_options) {
         opts.version = raw::GIT_CHECKOUT_OPTIONS_VERSION;
         opts.disable_filters = self.disable_filters as c_int;

src/call.rs

@@ -1,4 +1,3 @@
-#![allow(clippy::needless_lifetimes)]
 #![macro_use]
 
 use crate::Error;
@@ -69,12 +68,12 @@ mod impls {
             *self as libc::c_int
         }
     }
-    impl<'a, T> Convert<*const T> for &'a T {
+    impl<T> Convert<*const T> for &T {
         fn convert(&self) -> *const T {
             *self as *const T
         }
     }
-    impl<'a, T> Convert<*mut T> for &'a mut T {
+    impl<T> Convert<*mut T> for &mut T {
         fn convert(&self) -> *mut T {
             &**self as *const T as *mut T
         }

src/cherrypick.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::new_without_default)]
-
 use std::mem;
 
 use crate::build::CheckoutBuilder;
@@ -78,3 +76,10 @@ impl<'cb> CherrypickOptions<'cb> {
         cherrypick_opts
     }
 }
+
+impl<'cb> Default for CherrypickOptions<'cb> {
+    /// Creates a default set of cherrypick options
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/commit.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::redundant_closure)]
-
 use std::iter::FusedIterator;
 use std::marker;
 use std::mem;
@@ -84,7 +82,7 @@ impl<'repo> Commit<'repo> {
     pub fn message_encoding(&self) -> Result<Option<&str>, Error> {
         let bytes = unsafe { crate::opt_bytes(self, raw::git_commit_message_encoding(&*self.raw)) };
         match bytes {
-            Some(b) => str::from_utf8(b).map(|s| Some(s)).map_err(|e| e.into()),
+            Some(b) => str::from_utf8(b).map(Some).map_err(|e| e.into()),
             None => Ok(None),
         }
     }
@@ -131,7 +129,7 @@ impl<'repo> Commit<'repo> {
     /// `Ok(None)` may be returned if there is no summary
     pub fn summary(&self) -> Result<Option<&str>, Error> {
         match self.summary_bytes() {
-            Some(sb) => str::from_utf8(sb).map(|s| Some(s)).map_err(|e| e.into()),
+            Some(sb) => str::from_utf8(sb).map(Some).map_err(|e| e.into()),
             None => Ok(None),
         }
     }
@@ -155,7 +153,7 @@ impl<'repo> Commit<'repo> {
     /// `Ok(None)` may be returned if there is no body.
     pub fn body(&self) -> Result<Option<&str>, Error> {
         match self.body_bytes() {
-            Some(sb) => str::from_utf8(sb).map(|s| Some(s)).map_err(|e| e.into()),
+            Some(sb) => str::from_utf8(sb).map(Some).map_err(|e| e.into()),
             None => Ok(None),
         }
     }

src/config.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::should_implement_trait)]
-
 use std::ffi::CString;
 use std::marker;
 use std::path::{Path, PathBuf};
@@ -601,6 +599,7 @@ impl<'cfg> ConfigEntries<'cfg> {
     /// Advances the iterator and returns the next value.
     ///
     /// Returns `None` when iteration is finished.
+    #[expect(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Option<Result<&ConfigEntry<'cfg>, Error>> {
         let mut raw = ptr::null_mut();
         drop(self.current.take());

src/cred.rs

@@ -1,10 +1,3 @@
-#![allow(clippy::manual_strip)]
-#![allow(clippy::match_result_ok)]
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::needless_borrowed_reference)]
-#![allow(clippy::needless_borrows_for_generic_args)]
-#![allow(clippy::should_implement_trait)]
-
 #[cfg(feature = "cred")]
 use log::{debug, trace};
 use std::ffi::CString;
@@ -39,6 +32,7 @@ pub struct CredentialHelper {
 impl Cred {
     /// Create a "default" credential usable for Negotiate mechanisms like NTLM
     /// or Kerberos authentication.
+    #[expect(clippy::should_implement_trait)]
     pub fn default() -> Result<Cred, Error> {
         crate::init();
         let mut out = ptr::null_mut();
@@ -171,6 +165,11 @@ impl Cred {
     }
 
     /// Unwrap access to the underlying raw pointer, canceling the destructor
+    ///
+    /// # Safety
+    ///
+    /// The caller must assume responsibility for freeing the credential if
+    /// needed. See the drop implementation for guidance.
     pub unsafe fn unwrap(mut self) -> *mut raw::git_cred {
         mem::replace(&mut self.raw, ptr::null_mut())
     }
@@ -277,14 +276,14 @@ impl CredentialHelper {
     // Discover `useHttpPath` from `config`
     fn config_use_http_path(&mut self, config: &Config) {
         let mut use_http_path = false;
-        if let Some(value) = config.get_bool(&self.exact_key("useHttpPath")).ok() {
+        if let Ok(value) = config.get_bool(&self.exact_key("useHttpPath")) {
             use_http_path = value;
         } else if let Some(value) = self
             .url_key("useHttpPath")
             .and_then(|key| config.get_bool(&key).ok())
         {
             use_http_path = value;
-        } else if let Some(value) = config.get_bool("credential.useHttpPath").ok() {
+        } else if let Ok(value) = config.get_bool("credential.useHttpPath") {
             use_http_path = value;
         }
 
@@ -313,8 +312,8 @@ impl CredentialHelper {
             Some(s) => s,
         };
 
-        if cmd.starts_with('!') {
-            self.commands.push(cmd[1..].to_string());
+        if let Some(stripped) = cmd.strip_prefix('!') {
+            self.commands.push(stripped.to_string());
         } else if is_absolute_path(cmd) {
             self.commands.push(cmd.to_string());
         } else {
@@ -328,7 +327,7 @@ impl CredentialHelper {
 
     fn url_key(&self, name: &str) -> Option<String> {
         match (&self.host, &self.protocol) {
-            (&Some(ref host), &Some(ref protocol)) => {
+            (Some(host), Some(protocol)) => {
                 Some(format!("credential.{}://{}.{}", protocol, host, name))
             }
             _ => None,
@@ -398,7 +397,7 @@ impl CredentialHelper {
             c.creation_flags(CREATE_NO_WINDOW);
         }
         c.arg("-c")
-            .arg(&format!("{} get", cmd))
+            .arg(format!("{} get", cmd))
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
@@ -502,6 +501,7 @@ impl CredentialHelper {
 
 #[cfg(test)]
 #[cfg(feature = "cred")]
+#[allow(clippy::needless_borrows_for_generic_args)]
 #[allow(clippy::unused_io_amount)]
 #[allow(clippy::useless_conversion)]
 mod test {

src/diff.rs

@@ -1,7 +1,3 @@
-#![allow(clippy::empty_docs)]
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::new_without_default)]
-
 use libc::{c_char, c_int, c_void, size_t};
 use std::ffi::CString;
 use std::iter::FusedIterator;
@@ -956,6 +952,8 @@ impl DiffOptions {
 
     /// Acquire a pointer to the underlying raw options.
     ///
+    /// # Safety
+    ///
     /// This function is unsafe as the pointer is only valid so long as this
     /// structure is not moved, modified, or used elsewhere.
     pub unsafe fn raw(&mut self) -> *const raw::git_diff_options {
@@ -1000,9 +998,9 @@ impl<'diff> ExactSizeIterator for Deltas<'diff> {}
 pub enum DiffLineType {
     /// These values will be sent to `git_diff_line_cb` along with the line
     Context,
-    ///
+    /// Line was added
     Addition,
-    ///
+    /// Line was removed
     Deletion,
     /// Both files have no LF at end
     ContextEOFNL,
@@ -1013,7 +1011,7 @@ pub enum DiffLineType {
     /// The following values will only be sent to a `git_diff_line_cb` when
     /// the content of a diff is being formatted through `git_diff_print`.
     FileHeader,
-    ///
+    /// Line represents the header of a hunk, e.g. "@@ -1,2 +0,0 @@\n"
     HunkHeader,
     /// For "Binary files x and y differ"
     Binary,
@@ -1529,6 +1527,11 @@ impl DiffFindOptions {
     // TODO: expose git_diff_similarity_metric
 
     /// Acquire a pointer to the underlying raw options.
+    ///
+    /// # Safety
+    ///
+    /// The provided pointer must not be used to manipulate the options, and
+    /// must not outlive the [`DiffFindOptions`] instance.
     pub unsafe fn raw(&mut self) -> *const raw::git_diff_find_options {
         &self.raw
     }
@@ -1592,6 +1595,14 @@ impl DiffPatchidOptions {
     }
 }
 
+impl Default for DiffPatchidOptions {
+    /// Creates a new set of patchid options,
+    /// initialized to the default values
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[cfg(test)]
 #[allow(clippy::assign_op_pattern)]
 #[allow(clippy::needless_borrows_for_generic_args)]