From faf555907586e40e88fee55841b30815c89d7244 Mon Sep 17 00:00:00 2001
From: Julian Orth <ju.orth@gmail.com>
Date: Sun, 20 Oct 2024 18:50:06 +0200
Subject: [PATCH] it: handle new warnings

---
 src/it/test_config.rs   | 28 ++++++++++++++++------------
 src/leaks.rs            | 40 ++++++++++++++++++++++------------------
 src/tracy/tracy_impl.rs | 12 +++++++-----
 3 files changed, 45 insertions(+), 35 deletions(-)

diff --git a/src/it/test_config.rs b/src/it/test_config.rs
index 9ee4ce6a..59d87072 100644
--- a/src/it/test_config.rs
+++ b/src/it/test_config.rs
@@ -59,25 +59,29 @@ unsafe extern "C" fn init(
 ) -> *const u8 {
     let tc = CONFIG.get();
     assert!(tc.is_not_null());
-    Rc::increment_strong_count(tc);
-    {
-        let tc = &*tc;
-        tc.srv.set(Some(ServerData {
-            srv_data,
-            srv_unref,
-            srv_handler,
-        }));
+    unsafe {
+        Rc::increment_strong_count(tc);
+        {
+            let tc = &*tc;
+            tc.srv.set(Some(ServerData {
+                srv_data,
+                srv_unref,
+                srv_handler,
+            }));
+        }
+        tc.cast()
     }
-    tc.cast()
 }
 
 unsafe extern "C" fn unref(data: *const u8) {
-    Rc::decrement_strong_count(data.cast::<TestConfig>());
+    unsafe {
+        Rc::decrement_strong_count(data.cast::<TestConfig>());
+    }
 }
 
 unsafe extern "C" fn handle_msg(data: *const u8, msg: *const u8, size: usize) {
-    let tc = &*data.cast::<TestConfig>();
-    let msg = std::slice::from_raw_parts(msg, size);
+    let tc = unsafe { &*data.cast::<TestConfig>() };
+    let msg = unsafe { std::slice::from_raw_parts(msg, size) };
     let res = bincode_ops().deserialize::<ServerMessage>(msg);
     let msg = match res {
         Ok(msg) => msg,
diff --git a/src/leaks.rs b/src/leaks.rs
index d6158c4a..7d74105e 100644
--- a/src/leaks.rs
+++ b/src/leaks.rs
@@ -270,29 +270,33 @@ mod leaks {
 
     unsafe impl GlobalAlloc for TracingAllocator {
         unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-            let res = c::calloc(layout.size(), 1) as *mut u8;
-            if IN_ALLOCATOR.get() == 0 {
-                IN_ALLOCATOR.set(1);
-                ALLOCATIONS.get().deref_mut().insert(
-                    res,
-                    Allocation {
-                        addr: res,
-                        len: layout.size(),
-                        backtrace: Backtrace::new_unresolved(),
-                    },
-                );
-                // log::info!("allocated [0x{:x}, 0x{:x})", res as usize, res as usize + layout.size());
-                IN_ALLOCATOR.set(0);
+            unsafe {
+                let res = c::calloc(layout.size(), 1) as *mut u8;
+                if IN_ALLOCATOR.get() == 0 {
+                    IN_ALLOCATOR.set(1);
+                    ALLOCATIONS.get().deref_mut().insert(
+                        res,
+                        Allocation {
+                            addr: res,
+                            len: layout.size(),
+                            backtrace: Backtrace::new_unresolved(),
+                        },
+                    );
+                    // log::info!("allocated [0x{:x}, 0x{:x})", res as usize, res as usize + layout.size());
+                    IN_ALLOCATOR.set(0);
+                }
+                res
             }
-            res
         }
 
         unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-            if INITIALIZED.get() {
-                ALLOCATIONS.get().deref_mut().remove(&ptr);
+            unsafe {
+                if INITIALIZED.get() {
+                    ALLOCATIONS.get().deref_mut().remove(&ptr);
+                }
+                // c::memset(ptr as _, 0, layout.size());
+                c::free(ptr as _);
             }
-            // c::memset(ptr as _, 0, layout.size());
-            c::free(ptr as _);
         }
     }
 
diff --git a/src/tracy/tracy_impl.rs b/src/tracy/tracy_impl.rs
index 27bbd04b..94e7c3f4 100644
--- a/src/tracy/tracy_impl.rs
+++ b/src/tracy/tracy_impl.rs
@@ -183,16 +183,18 @@ unsafe extern "C" fn ___tracy_demangle(
     if mangled.is_null() {
         return ptr::null();
     }
-    let Ok(mangled) = CStr::from_ptr(mangled).to_str() else {
+    let Ok(mangled) = unsafe { CStr::from_ptr(mangled) }.to_str() else {
         return ptr::null();
     };
     let demangled = rustc_demangle::demangle(mangled);
     static mut BUF: Vec<u8> = Vec::new();
-    BUF.clear();
-    if write!(BUF, "{demangled:#}\0").is_err() {
-        return ptr::null();
+    unsafe {
+        BUF.clear();
+        if write!(BUF, "{demangled:#}\0").is_err() {
+            return ptr::null();
+        }
+        BUF.as_ptr().cast()
     }
-    BUF.as_ptr().cast()
 }
 
 static ENABLED: AtomicBool = AtomicBool::new(false);