style: cargo clippy --fix and fmt on Rust v1.84

profiling/src/allocation.rs

@@ -10,9 +10,9 @@ use log::{debug, error, trace, warn};
 use rand::rngs::ThreadRng;
 use rand_distr::{Distribution, Poisson};
 use std::cell::{RefCell, UnsafeCell};
+use std::ptr;
 use std::sync::atomic::AtomicU64;
 use std::sync::atomic::Ordering::{Relaxed, SeqCst};
-use std::{ffi, ptr};
 
 static mut GC_MEM_CACHES_HANDLER: zend::InternalFunctionHandler = None;
 
@@ -318,7 +318,7 @@ pub fn alloc_prof_rshutdown() {
 pub fn alloc_prof_startup() {
     unsafe {
         let handle = datadog_php_zif_handler::new(
-            ffi::CStr::from_bytes_with_nul_unchecked(b"gc_mem_caches\0"),
+            c"gc_mem_caches",
             ptr::addr_of_mut!(GC_MEM_CACHES_HANDLER),
             Some(alloc_prof_gc_mem_caches),
         );

profiling/src/bindings/mod.rs

@@ -568,7 +568,7 @@ impl<'a> From<&'a str> for ZaiStr<'a> {
     }
 }
 
-impl<'a> Default for ZaiStr<'a> {
+impl Default for ZaiStr<'_> {
     fn default() -> Self {
         Self::new()
     }

profiling/src/exception.rs

@@ -4,7 +4,6 @@ use crate::REQUEST_LOCALS;
 use log::{error, info};
 use rand::rngs::ThreadRng;
 use std::cell::RefCell;
-use std::ffi::CStr;
 use std::ptr;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
@@ -136,8 +135,8 @@ pub fn exception_profiling_minit() {
         zend::zend_throw_exception_hook = Some(exception_profiling_throw_exception_hook);
 
         let method_handlers = [zend::datadog_php_zim_handler::new(
-            CStr::from_bytes_with_nul_unchecked(b"generator\0"),
-            CStr::from_bytes_with_nul_unchecked(b"throw\0"),
+            c"generator",
+            c"throw",
             ptr::addr_of_mut!(GENERATOR_THROW_HANDLER),
             Some(ddog_php_prof_generator_throw),
         )];

profiling/src/profiling/stack_walking.rs

@@ -95,7 +95,7 @@ mod detail {
         string_set: &'a mut StringSet,
     }
 
-    impl<'a> StringCache<'a> {
+    impl StringCache<'_> {
         /// Makes a copy of the string in the cache slot. If there isn't a
         /// string in the slot currently, then create one by calling the
         /// provided function, store it in the string cache and cache slot,

profiling/src/sapi.rs

@@ -62,7 +62,7 @@ impl Sapi {
                     // Safety: It's not null; the VM should do the rest.
                     let cstr = unsafe { CStr::from_ptr(*sapi_request_info.argv) };
                     let bytes = cstr.to_bytes();
-                    return if !bytes.is_empty() {
+                    if !bytes.is_empty() {
                         let osstr = OsStr::from_bytes(bytes);
                         Path::new(osstr)
                             .file_name()
@@ -82,7 +82,7 @@ impl Sapi {
                             })
                     } else {
                         None
-                    };
+                    }
                 } else {
                     None
                 }

profiling/src/thin_str.rs

@@ -55,7 +55,7 @@ impl<'a> ThinStr<'a> {
     }
 }
 
-impl<'a> Deref for ThinStr<'a> {
+impl Deref for ThinStr<'_> {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -75,21 +75,21 @@ impl<'a> Deref for ThinStr<'a> {
     }
 }
 
-impl<'a> hash::Hash for ThinStr<'a> {
+impl hash::Hash for ThinStr<'_> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.deref().hash(state)
     }
 }
 
-impl<'a> PartialEq for ThinStr<'a> {
+impl PartialEq for ThinStr<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.deref().eq(other.deref())
     }
 }
 
-impl<'a> Eq for ThinStr<'a> {}
+impl Eq for ThinStr<'_> {}
 
-impl<'a> Borrow<str> for ThinStr<'a> {
+impl Borrow<str> for ThinStr<'_> {
     fn borrow(&self) -> &str {
         self.deref()
     }