refactor: replace allow(...) with expect(...) or drop when unused

The `expect` attribute, stabilized in Rust 1.81, is stricter than
`allow`: it verifies that the suppressed lint actually fires. This
surfaces stale suppressions and prevents silently hiding new issues.

Convert remaining `allow(...)` attributes to `expect(...)` across the
codebase where the suppression is genuinely load-bearing. For items
that are dead in non-test builds but used by tests, use
`#[cfg_attr(not(test), expect(dead_code))]` so the expectation holds
under every configuration.

Several `allow(...)` attributes turned out to be suppressing nothing at
all — drop them. Examples:

- `Range::range` and `Range::empty` are called from the merge path.
- `ParseOpts::no_skip_preamble` is called from the patch set parser.
- `Text::ends_with` and `Text::lines` are called through the trait.
- The `Diff` enum and `DiffOptions::diff` are reachable through the
  free `diff` fn, which is the only real anchor in that chain.
- A number of `needless_lifetimes` annotations as the lint was relaxed
  upstream.

These were all silently wrong under `allow`; `expect` caught them.

Author: Brandon Williams

src/binary/base85.rs

@@ -90,7 +90,8 @@ pub fn decode_into(input: &[u8], output: &mut impl Extend<u8>) -> Result<(), Bas
 /// Callers encoding data where the byte count isn't a multiple of 4
 /// must handle padding at a higher level.
 /// For example, via a length indicator in Git binary patch format.
-#[allow(dead_code)] // will be used for patch formatting
+// will be used for patch formatting
+#[cfg_attr(not(test), expect(dead_code))]
 pub fn encode_into(input: &[u8], output: &mut impl Extend<char>) -> Result<(), Base85Error> {
     if input.len() % 4 != 0 {
         return Err(Base85Error::InvalidLength);

src/diff/cleanup.rs

@@ -4,7 +4,6 @@ use alloc::vec::Vec;
 
 // Walks through all edits and shifts them up and then down, trying to see if they run into similar
 // edits which can be merged
-#[allow(clippy::needless_lifetimes)]
 pub fn compact<'a, 'b, T: ?Sized + SliceLike>(diffs: &mut Vec<DiffRange<'a, 'b, T>>) {
     // First attempt to compact all Deletions
     let mut pointer = 0;
@@ -29,7 +28,6 @@ pub fn compact<'a, 'b, T: ?Sized + SliceLike>(diffs: &mut Vec<DiffRange<'a, 'b,
 }
 
 // Attempts to shift the Insertion or Deletion at location `pointer` as far upwards as possible.
-#[allow(clippy::needless_lifetimes)]
 fn shift_diff_up<'a, 'b, T: ?Sized + SliceLike>(
     diffs: &mut Vec<DiffRange<'a, 'b, T>>,
     mut pointer: usize,
@@ -131,7 +129,6 @@ fn shift_diff_up<'a, 'b, T: ?Sized + SliceLike>(
 }
 
 // Attempts to shift the Insertion or Deletion at location `pointer` as far downwards as possible.
-#[allow(clippy::needless_lifetimes)]
 fn shift_diff_down<'a, 'b, T: ?Sized + SliceLike>(
     diffs: &mut Vec<DiffRange<'a, 'b, T>>,
     mut pointer: usize,

src/diff/mod.rs

@@ -17,7 +17,6 @@ mod myers;
 mod tests;
 
 // TODO determine if this should be exposed in the public API
-#[allow(dead_code)]
 #[derive(Debug, PartialEq, Eq)]
 enum Diff<'a, T: ?Sized> {
     Equal(&'a T),
@@ -117,7 +116,7 @@ impl DiffOptions {
     /// produce a prettier diff by reducing the number of edited blocks by shifting and merging
     /// edit blocks.
     // TODO determine if this should be exposed in the public API
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     fn set_compact(&mut self, compact: bool) -> &mut Self {
         self.compact = compact;
         self
@@ -146,7 +145,6 @@ impl DiffOptions {
     }
 
     // TODO determine if this should be exposed in the public API
-    #[allow(dead_code)]
     fn diff<'a>(&self, original: &'a str, modified: &'a str) -> Vec<Diff<'a, str>> {
         let solution = myers::diff(original.as_bytes(), modified.as_bytes());
 
@@ -229,7 +227,7 @@ impl Default for DiffOptions {
 }
 
 // TODO determine if this should be exposed in the public API
-#[allow(dead_code)]
+#[cfg_attr(not(test), expect(dead_code))]
 fn diff<'a>(original: &'a str, modified: &'a str) -> Vec<Diff<'a, str>> {
     DiffOptions::default().diff(original, modified)
 }

src/merge/mod.rs

@@ -524,7 +524,6 @@ fn create_merge_range<'ancestor, 'ours, 'theirs, T: ?Sized + SliceLike>(
     }
 }
 
-#[allow(clippy::needless_lifetimes)]
 fn cleanup_conflicts<'ancestor, 'ours, 'theirs, T: ?Sized + SliceLike + PartialEq>(
     solution: &mut [MergeRange<'ancestor, 'ours, 'theirs, T>],
 ) {

src/patch/mod.rs

@@ -146,7 +146,7 @@ impl<'a> Patch<'a, str> {
     ///
     /// let patch = Patch::from_str(s).unwrap();
     /// ```
-    #[allow(clippy::should_implement_trait)]
+    #[expect(clippy::should_implement_trait)]
     pub fn from_str(s: &'a str) -> Result<Patch<'a, str>, ParsePatchError> {
         parse::parse(s)
     }

src/patch/parse.rs

@@ -38,7 +38,6 @@ impl ParseOpts {
     ///
     /// Useful when the caller has already positioned the input
     /// at the start of the patch content.
-    #[allow(dead_code)] // will be used by patch_set parser
     pub(crate) fn no_skip_preamble(mut self) -> Self {
         self.skip_preamble = false;
         self
@@ -145,7 +144,7 @@ pub(crate) fn parse_one<T: Text + ?Sized>(
     (Ok(Patch::new(header.0, header.1, hunks)), parser.offset())
 }
 
-#[allow(clippy::type_complexity)]
+#[expect(clippy::type_complexity)]
 fn patch_header<'a, T: Text + ?Sized>(
     parser: &mut Parser<'a, T>,
     opts: &ParseOpts,

src/range.rs

@@ -35,7 +35,6 @@ impl<'a, T: ?Sized> Range<'a, T> {
         self.offset
     }
 
-    #[allow(dead_code)]
     pub fn range(&self) -> ops::Range<usize> {
         self.offset..self.offset + self.len
     }
@@ -98,7 +97,6 @@ where
         Range { inner, offset, len }
     }
 
-    #[allow(dead_code)]
     pub fn empty() -> Range<'a, T> {
         Range {
             inner: T::empty(),
@@ -119,17 +117,17 @@ where
         self.as_slice().common_suffix_len(other.as_slice())
     }
 
-    #[allow(dead_code)]
+    #[cfg_attr(not(test), expect(dead_code))]
     pub fn common_overlap_len(&self, other: Range<'_, T>) -> usize {
         self.as_slice().common_overlap_len(other.as_slice())
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn starts_with(&self, prefix: Range<'_, T>) -> bool {
         self.as_slice().starts_with(prefix.as_slice())
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub fn ends_with(&self, suffix: Range<'_, T>) -> bool {
         self.as_slice().ends_with(suffix.as_slice())
     }

src/utils.rs

@@ -140,7 +140,6 @@ pub trait Text: Eq + Hash + ToOwned {
     fn is_empty(&self) -> bool;
     fn len(&self) -> usize;
     fn starts_with(&self, prefix: &str) -> bool;
-    #[allow(unused)]
     fn ends_with(&self, suffix: &str) -> bool;
     fn strip_prefix(&self, prefix: &str) -> Option<&Self>;
     fn strip_suffix(&self, suffix: &str) -> Option<&Self>;
@@ -149,7 +148,6 @@ pub trait Text: Eq + Hash + ToOwned {
     fn split_at(&self, mid: usize) -> (&Self, &Self);
     fn as_str(&self) -> Option<&str>;
     fn as_bytes(&self) -> &[u8];
-    #[allow(unused)]
     fn lines(&self) -> LineIter<'_, Self>;
 
     /// Converts raw bytes into `Self::Owned`.