Fix some nightly warnings (#54)

This commit can be replicated by running `cargo fix` with rustc +nightly-2025-09-07.

An example warning that this fixes:
```
warning: hiding a lifetime that's elided elsewhere is confusing
   --> src/instrumentation_profile/text_profile.rs:120:39
    |
120 | fn read_value_profile_data(mut input: &[u8]) -> ParseResult<Option<Box<ValueProfDataRecord>>> {
    |                                       ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the same lifetime is hidden here
    |                                       |
    |                                       the lifetime is elided here
    |
    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
help: use `'_` for type paths
    |
120 | fn read_value_profile_data(mut input: &[u8]) -> ParseResult<'_, Option<Box<ValueProfDataRecord>>> {
    |                                                             +++
```

Author: jyn514

src/hash_table.rs

@@ -16,14 +16,14 @@ struct KeyDataLen {
 #[derive(Clone, Debug)]
 pub(crate) struct HashTable(pub IndexMap<(u64, String), InstrProfRecord>);
 
-fn read_key_data_len(input: &[u8]) -> ParseResult<KeyDataLen> {
+fn read_key_data_len(input: &[u8]) -> ParseResult<'_, KeyDataLen> {
     let (bytes, key_len) = le_u64(input)?;
     let (bytes, data_len) = le_u64(bytes)?;
     let res = KeyDataLen { key_len, data_len };
     Ok((bytes, res))
 }
 
-fn read_key(input: &[u8], key_len: usize) -> ParseResult<Cow<'_, str>> {
+fn read_key(input: &[u8], key_len: usize) -> ParseResult<'_, Cow<'_, str>> {
     if key_len > input.len() {
         Err(nom::Err::Failure(VerboseError::from_error_kind(
             &input[input.len()..],
@@ -39,7 +39,7 @@ fn read_value(
     version: u64,
     mut input: &[u8],
     data_len: usize,
-) -> ParseResult<(u64, InstrProfRecord)> {
+) -> ParseResult<'_, (u64, InstrProfRecord)> {
     if data_len % 8 != 0 {
         // Element is corrupted, it should be aligned
         let errors = vec![(

src/instrumentation_profile/indexed_profile.rs

@@ -164,7 +164,7 @@ fn parse_summary<'a>(
 impl InstrProfReader for IndexedInstrProf {
     type Header = Header;
 
-    fn parse_bytes(mut input: &[u8]) -> ParseResult<InstrumentationProfile> {
+    fn parse_bytes(mut input: &[u8]) -> ParseResult<'_, InstrumentationProfile> {
         let (bytes, header) = Self::parse_header(input)?;
         debug!("Parsed header: {:?}", header);
         let (bytes, summary) = parse_summary(bytes, &header, false)?;
@@ -210,7 +210,7 @@ impl InstrProfReader for IndexedInstrProf {
         Ok((input, profile))
     }
 
-    fn parse_header(input: &[u8]) -> ParseResult<Self::Header> {
+    fn parse_header(input: &[u8]) -> ParseResult<'_, Self::Header> {
         if Self::has_format(input) {
             let (bytes, version) = le_u64(&input[8..])?;
             let (bytes, _) = le_u64(bytes)?;

src/instrumentation_profile/mod.rs

@@ -52,9 +52,9 @@ pub fn parse_bytes(data: &[u8]) -> io::Result<InstrumentationProfile> {
 pub trait InstrProfReader {
     type Header;
     /// Parse the profile no lazy parsing here!
-    fn parse_bytes(input: &[u8]) -> ParseResult<InstrumentationProfile>;
+    fn parse_bytes(input: &[u8]) -> ParseResult<'_, InstrumentationProfile>;
     /// Parses a header
-    fn parse_header(input: &[u8]) -> ParseResult<Self::Header>;
+    fn parse_header(input: &[u8]) -> ParseResult<'_, Self::Header>;
     /// Detects that the bytes match the current reader format if it can't read the format it will
     /// return false
     fn has_format(input: impl Read) -> bool;

src/instrumentation_profile/raw_profile.rs

@@ -292,7 +292,7 @@ where
 {
     type Header = Header;
 
-    fn parse_bytes(mut input: &[u8]) -> ParseResult<InstrumentationProfile> {
+    fn parse_bytes(mut input: &[u8]) -> ParseResult<'_, InstrumentationProfile> {
         if !input.is_empty() {
             let mut result = InstrumentationProfile::default();
             let (bytes, header) = Self::parse_header(input)?;
@@ -417,7 +417,7 @@ where
         }
     }
 
-    fn parse_header(input: &[u8]) -> ParseResult<Self::Header> {
+    fn parse_header(input: &[u8]) -> ParseResult<'_, Self::Header> {
         if Self::has_format(input) {
             let endianness = file_endianness::<T>(&input[..8].try_into().unwrap());
             let (bytes, version) = nom_u64(endianness)(&input[8..])?;

src/instrumentation_profile/text_profile.rs

@@ -47,7 +47,7 @@ fn str_to_digit(bytes: &[u8]) -> u64 {
         .unwrap_or_default()
 }
 
-fn read_hexadecimal(input: &[u8]) -> ParseResult<u64> {
+fn read_hexadecimal(input: &[u8]) -> ParseResult<'_, u64> {
     preceded(alt((tag(b"0x"), tag(b"0X"))), take_while1(is_hex_digit))(input).map(|(b, v)| unsafe {
         // We know this is okay because it's just the bytes that pass `is_hex_digit`
         (
@@ -63,11 +63,11 @@ fn valid_name_char(character: u8) -> bool {
     c.is_ascii() && c != '\n' && c != '\r'
 }
 
-fn strip_whitespace(s: &[u8]) -> ParseResult<()> {
+fn strip_whitespace(s: &[u8]) -> ParseResult<'_, ()> {
     one_of(&b" \n\r\t"[..])(s).map(|(b, _)| (b, ()))
 }
 
-fn strip_comments(s: &[u8]) -> ParseResult<()> {
+fn strip_comments(s: &[u8]) -> ParseResult<'_, ()> {
     delimited(
         tag(b"#"),
         alt((take_until("\r"), take_until("\n"))),
@@ -76,11 +76,11 @@ fn strip_comments(s: &[u8]) -> ParseResult<()> {
     .map(|(b, _)| (b, ()))
 }
 
-fn skip_to_content(s: &[u8]) -> ParseResult<()> {
+fn skip_to_content(s: &[u8]) -> ParseResult<'_, ()> {
     many0(alt((strip_whitespace, strip_comments)))(s).map(|(b, _)| (b, ()))
 }
 
-fn match_header_tags(s: &[u8]) -> ParseResult<&[u8]> {
+fn match_header_tags(s: &[u8]) -> ParseResult<'_, &[u8]> {
     alt((
         tag_no_case(IR_TAG),
         tag_no_case(FE_TAG),
@@ -91,33 +91,33 @@ fn match_header_tags(s: &[u8]) -> ParseResult<&[u8]> {
     ))(s)
 }
 
-fn parse_header_tags(s: &[u8]) -> ParseResult<Vec<&[u8]>> {
+fn parse_header_tags(s: &[u8]) -> ParseResult<'_, Vec<&[u8]>> {
     many0(delimited(tag(b":"), match_header_tags, line_ending))(s)
 }
 
-fn read_line(s: &[u8]) -> ParseResult<&[u8]> {
+fn read_line(s: &[u8]) -> ParseResult<'_, &[u8]> {
     tuple((take_while1(valid_name_char), line_ending))(s).map(|(b, (v, _))| (b, v))
 }
 
-fn read_decimal(s: &[u8]) -> ParseResult<u64> {
+fn read_decimal(s: &[u8]) -> ParseResult<'_, u64> {
     tuple((take_while1(is_digit), alt((line_ending, eof))))(s).map(|(b, v)| (b, str_to_digit(v.0)))
 }
 
-fn read_digit(s: &[u8]) -> ParseResult<u64> {
+fn read_digit(s: &[u8]) -> ParseResult<'_, u64> {
     alt((read_decimal, read_hexadecimal))(s)
 }
 
-fn indirect_value_site(s: &[u8]) -> ParseResult<(&[u8], u64)> {
+fn indirect_value_site(s: &[u8]) -> ParseResult<'_, (&[u8], u64)> {
     tuple((take_until(":"), tag(":"), take_while1(is_digit)))(s)
         .map(|(b, v)| (b, (v.0, str_to_digit(v.2))))
 }
 
-fn memop_value_site(s: &[u8]) -> ParseResult<(u64, u64)> {
+fn memop_value_site(s: &[u8]) -> ParseResult<'_, (u64, u64)> {
     tuple((take_while1(is_digit), tag(":"), take_while1(is_digit)))(s)
         .map(|(b, v)| (b, (str_to_digit(v.0), str_to_digit(v.2))))
 }
 
-fn read_value_profile_data(mut input: &[u8]) -> ParseResult<Option<Box<ValueProfDataRecord>>> {
+fn read_value_profile_data(mut input: &[u8]) -> ParseResult<'_, Option<Box<ValueProfDataRecord>>> {
     if let Ok((bytes, n_kinds)) = read_digit(input) {
         let mut record = Box::<ValueProfDataRecord>::default();
         // We have value profiling data!
@@ -190,7 +190,7 @@ fn read_value_profile_data(mut input: &[u8]) -> ParseResult<Option<Box<ValueProf
 
 impl InstrProfReader for TextInstrProf {
     type Header = Header;
-    fn parse_bytes(mut input: &[u8]) -> ParseResult<InstrumentationProfile> {
+    fn parse_bytes(mut input: &[u8]) -> ParseResult<'_, InstrumentationProfile> {
         let (bytes, header) = Self::parse_header(input)?;
         let (bytes, _) = skip_to_content(bytes)?;
         input = bytes;
@@ -252,7 +252,7 @@ impl InstrProfReader for TextInstrProf {
         Ok((bytes, result))
     }
 
-    fn parse_header(input: &[u8]) -> ParseResult<Self::Header> {
+    fn parse_header(input: &[u8]) -> ParseResult<'_, Self::Header> {
         let (input, _) = skip_to_content(input)?;
         let (bytes, names) = parse_header_tags(input)?;
         let mut is_ir_level = false;