[Rust] Simplify usage surrounding c strings

`cstring.as_ref().as_ptr() as *const c_char` -> `cstring.as_ptr()`
`cstring.as_ref().as_ptr() as *mut _` -> `cstring.as_ptr()`
`cstring.as_ptr() as *const c_char` -> `cstring.as_ptr()`

With a few fixes for cstrings that might be dropped prematurely.

55 files changed, 539 insertions, 1192 deletions

diff --git a/rust/src/architecture.rs b/rust/src/architecture.rs
index 74a8dfa4..62693800 100644
--- a/rust/src/architecture.rs
+++ b/rust/src/architecture.rs
@@ -1404,7 +1404,8 @@ impl CoreArchitecture {
     }
 
     pub fn by_name(name: &str) -> Option<Self> {
-        let handle = unsafe { BNGetArchitectureByName(name.to_cstr().as_ptr() as *mut _) };
+        let name = name.to_cstr();
+        let handle = unsafe { BNGetArchitectureByName(name.as_ptr()) };
         match handle.is_null() {
             false => Some(CoreArchitecture { handle }),
             true => None,
@@ -1955,9 +1956,7 @@ pub trait ArchitectureExt: Architecture {
     fn register_by_name<S: AsCStr>(&self, name: S) -> Option<Self::Register> {
         let name = name.to_cstr();
 
-        match unsafe {
-            BNGetArchitectureRegisterByName(self.as_ref().handle, name.as_ref().as_ptr() as *mut _)
-        } {
+        match unsafe { BNGetArchitectureRegisterByName(self.as_ref().handle, name.as_ptr()) } {
             0xffff_ffff => None,
             reg => self.register_from_id(reg.into()),
         }
@@ -3220,8 +3219,7 @@ where
     };
 
     unsafe {
-        let res =
-            BNRegisterArchitecture(name.as_ref().as_ptr() as *mut _, &mut custom_arch as *mut _);
+        let res = BNRegisterArchitecture(name.as_ptr(), &mut custom_arch as *mut _);
 
         assert!(!res.is_null());
 
diff --git a/rust/src/background_task.rs b/rust/src/background_task.rs
index c9059aca..95bdda0b 100644
--- a/rust/src/background_task.rs
+++ b/rust/src/background_task.rs
@@ -45,7 +45,7 @@ impl BackgroundTask {
 
     pub fn new<S: AsCStr>(initial_text: S, can_cancel: bool) -> Ref<Self> {
         let text = initial_text.to_cstr();
-        let handle = unsafe { BNBeginBackgroundTask(text.as_ref().as_ptr() as *mut _, can_cancel) };
+        let handle = unsafe { BNBeginBackgroundTask(text.as_ptr(), can_cancel) };
         // We should always be returned a valid task.
         assert!(!handle.is_null());
         unsafe { Ref::new(Self { handle }) }
@@ -77,9 +77,7 @@ impl BackgroundTask {
 
     pub fn set_progress_text<S: AsCStr>(&self, text: S) {
         let progress_text = text.to_cstr();
-        unsafe {
-            BNSetBackgroundTaskProgressText(self.handle, progress_text.as_ref().as_ptr() as *mut _)
-        }
+        unsafe { BNSetBackgroundTaskProgressText(self.handle, progress_text.as_ptr()) }
     }
 
     pub fn running_tasks() -> Array<BackgroundTask> {
diff --git a/rust/src/binary_view.rs b/rust/src/binary_view.rs
index 854f58f4..a0fb9081 100644
--- a/rust/src/binary_view.rs
+++ b/rust/src/binary_view.rs
@@ -267,12 +267,8 @@ pub trait BinaryViewExt: BinaryViewBase {
     }
 
     fn add_analysis_option(&self, name: impl AsCStr) {
-        unsafe {
-            BNAddAnalysisOption(
-                self.as_ref().handle,
-                name.to_cstr().as_ref().as_ptr() as *mut _,
-            )
-        }
+        let name = name.to_cstr();
+        unsafe { BNAddAnalysisOption(self.as_ref().handle, name.as_ptr()) }
     }
 
     fn has_initial_analysis(&self) -> bool {
@@ -409,7 +405,7 @@ pub trait BinaryViewExt: BinaryViewBase {
         unsafe {
             let raw_sym_ptr = BNGetSymbolByRawName(
                 self.as_ref().handle,
-                raw_name.as_ref().as_ptr() as *mut _,
+                raw_name.as_ptr(),
                 std::ptr::null_mut(),
             );
             match raw_sym_ptr.is_null() {
@@ -435,7 +431,7 @@ pub trait BinaryViewExt: BinaryViewBase {
             let mut count = 0;
             let handles = BNGetSymbolsByName(
                 self.as_ref().handle,
-                raw_name.as_ref().as_ptr() as *mut _,
+                raw_name.as_ptr(),
                 &mut count,
                 std::ptr::null_mut(),
             );
@@ -768,10 +764,9 @@ pub trait BinaryViewExt: BinaryViewBase {
     }
 
     fn type_by_id<S: AsCStr>(&self, id: S) -> Option<Ref<Type>> {
+        let id_str = id.to_cstr();
         unsafe {
-            let id_str = id.to_cstr();
-            let type_handle =
-                BNGetAnalysisTypeById(self.as_ref().handle, id_str.as_ref().as_ptr() as *mut _);
+            let type_handle = BNGetAnalysisTypeById(self.as_ref().handle, id_str.as_ptr());
             if type_handle.is_null() {
                 return None;
             }
@@ -780,10 +775,9 @@ pub trait BinaryViewExt: BinaryViewBase {
     }
 
     fn type_name_by_id<S: AsCStr>(&self, id: S) -> Option<QualifiedName> {
+        let id_str = id.to_cstr();
         unsafe {
-            let id_str = id.to_cstr();
-            let name_handle =
-                BNGetAnalysisTypeNameById(self.as_ref().handle, id_str.as_ref().as_ptr() as *mut _);
+            let name_handle = BNGetAnalysisTypeNameById(self.as_ref().handle, id_str.as_ptr());
             let name = QualifiedName::from_owned_raw(name_handle);
             // The core will return an empty qualified name if no type name was found.
             match name.items.is_empty() {
@@ -879,7 +873,7 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn remove_auto_section<S: AsCStr>(&self, name: S) {
         let raw_name = name.to_cstr();
-        let raw_name_ptr = raw_name.as_ref().as_ptr() as *mut _;
+        let raw_name_ptr = raw_name.as_ptr();
         unsafe {
             BNRemoveAutoSection(self.as_ref().handle, raw_name_ptr);
         }
@@ -887,7 +881,7 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn remove_user_section<S: AsCStr>(&self, name: S) {
         let raw_name = name.to_cstr();
-        let raw_name_ptr = raw_name.as_ref().as_ptr() as *mut _;
+        let raw_name_ptr = raw_name.as_ptr();
         unsafe {
             BNRemoveUserSection(self.as_ref().handle, raw_name_ptr);
         }
@@ -896,7 +890,7 @@ pub trait BinaryViewExt: BinaryViewBase {
     fn section_by_name<S: AsCStr>(&self, name: S) -> Option<Ref<Section>> {
         unsafe {
             let raw_name = name.to_cstr();
-            let name_ptr = raw_name.as_ref().as_ptr() as *mut _;
+            let name_ptr = raw_name.as_ptr();
             let raw_section_ptr = BNGetSectionByName(self.as_ref().handle, name_ptr);
             match raw_section_ptr.is_null() {
                 false => Some(Section::ref_from_raw(raw_section_ptr)),
@@ -1112,22 +1106,14 @@ pub trait BinaryViewExt: BinaryViewBase {
     fn show_graph_report<S: AsCStr>(&self, raw_name: S, graph: &FlowGraph) {
         let raw_name = raw_name.to_cstr();
         unsafe {
-            BNShowGraphReport(
-                self.as_ref().handle,
-                raw_name.as_ref().as_ptr() as *mut _,
-                graph.handle,
-            );
+            BNShowGraphReport(self.as_ref().handle, raw_name.as_ptr(), graph.handle);
         }
     }
 
     fn load_settings<S: AsCStr>(&self, view_type_name: S) -> Result<Ref<Settings>> {
         let view_type_name = view_type_name.to_cstr();
-        let settings_handle = unsafe {
-            BNBinaryViewGetLoadSettings(
-                self.as_ref().handle,
-                view_type_name.as_ref().as_ptr() as *mut _,
-            )
-        };
+        let settings_handle =
+            unsafe { BNBinaryViewGetLoadSettings(self.as_ref().handle, view_type_name.as_ptr()) };
 
         if settings_handle.is_null() {
             Err(())
@@ -1142,7 +1128,7 @@ pub trait BinaryViewExt: BinaryViewBase {
         unsafe {
             BNBinaryViewSetLoadSettings(
                 self.as_ref().handle,
-                view_type_name.as_ref().as_ptr() as *mut _,
+                view_type_name.as_ptr(),
                 settings.handle,
             )
         };
@@ -1170,7 +1156,7 @@ pub trait BinaryViewExt: BinaryViewBase {
     fn tag_type_by_name<S: AsCStr>(&self, name: S) -> Option<Ref<TagType>> {
         let name = name.to_cstr();
         unsafe {
-            let handle = BNGetTagType(self.as_ref().handle, name.as_ref().as_ptr() as *mut _);
+            let handle = BNGetTagType(self.as_ref().handle, name.as_ptr());
             if handle.is_null() {
                 return None;
             }
@@ -1184,7 +1170,7 @@ pub trait BinaryViewExt: BinaryViewBase {
     fn tag_by_id<S: AsCStr>(&self, id: S) -> Option<Ref<Tag>> {
         let id = id.to_cstr();
         unsafe {
-            let handle = BNGetTag(self.as_ref().handle, id.as_ref().as_ptr() as *mut _);
+            let handle = BNGetTag(self.as_ref().handle, id.as_ptr());
             if handle.is_null() {
                 return None;
             }
@@ -1234,13 +1220,7 @@ pub trait BinaryViewExt: BinaryViewBase {
     /// function use [`Function::set_comment_at`]
     fn set_comment_at(&self, addr: u64, comment: impl AsCStr) {
         let comment_raw = comment.to_cstr();
-        unsafe {
-            BNSetGlobalCommentForAddress(
-                self.as_ref().handle,
-                addr,
-                comment_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNSetGlobalCommentForAddress(self.as_ref().handle, addr, comment_raw.as_ptr()) }
     }
 
     /// Retrieves a list of the next disassembly lines.
@@ -1292,12 +1272,9 @@ pub trait BinaryViewExt: BinaryViewBase {
     }
 
     fn query_metadata<S: AsCStr>(&self, key: S) -> Option<Ref<Metadata>> {
-        let value: *mut BNMetadata = unsafe {
-            BNBinaryViewQueryMetadata(
-                self.as_ref().handle,
-                key.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let key = key.to_cstr();
+        let value: *mut BNMetadata =
+            unsafe { BNBinaryViewQueryMetadata(self.as_ref().handle, key.as_ptr()) };
         if value.is_null() {
             None
         } else {
@@ -1318,10 +1295,11 @@ pub trait BinaryViewExt: BinaryViewBase {
         V: Into<Ref<Metadata>>,
     {
         let md = value.into();
+        let key = key.to_cstr();
         unsafe {
             BNBinaryViewStoreMetadata(
                 self.as_ref().handle,
-                key.to_cstr().as_ref().as_ptr() as *const c_char,
+                key.as_ptr(),
                 md.as_ref().handle,
                 is_auto,
             )
@@ -1329,12 +1307,8 @@ pub trait BinaryViewExt: BinaryViewBase {
     }
 
     fn remove_metadata<S: AsCStr>(&self, key: S) {
-        unsafe {
-            BNBinaryViewRemoveMetadata(
-                self.as_ref().handle,
-                key.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let key = key.to_cstr();
+        unsafe { BNBinaryViewRemoveMetadata(self.as_ref().handle, key.as_ptr()) };
     }
 
     /// Retrieves a list of [CodeReference]s pointing to a given address.
@@ -1460,12 +1434,7 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn component_by_guid<S: AsCStr>(&self, guid: S) -> Option<Ref<Component>> {
         let name = guid.to_cstr();
-        let result = unsafe {
-            BNGetComponentByGuid(
-                self.as_ref().handle,
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNGetComponentByGuid(self.as_ref().handle, name.as_ptr()) };
         NonNull::new(result).map(|h| unsafe { Component::ref_from_raw(h) })
     }
 
@@ -1476,12 +1445,7 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn component_by_path<P: AsCStr>(&self, path: P) -> Option<Ref<Component>> {
         let path = path.to_cstr();
-        let result = unsafe {
-            BNGetComponentByPath(
-                self.as_ref().handle,
-                path.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNGetComponentByPath(self.as_ref().handle, path.as_ptr()) };
         NonNull::new(result).map(|h| unsafe { Component::ref_from_raw(h) })
     }
 
@@ -1491,12 +1455,7 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn remove_component_by_guid<P: AsCStr>(&self, guid: P) -> bool {
         let path = guid.to_cstr();
-        unsafe {
-            BNRemoveComponentByGuid(
-                self.as_ref().handle,
-                path.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNRemoveComponentByGuid(self.as_ref().handle, path.as_ptr()) }
     }
 
     fn data_variable_parent_components(&self, data_variable: &DataVariable) -> Array<Component> {
@@ -1519,24 +1478,15 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn external_library<S: AsCStr>(&self, name: S) -> Option<Ref<ExternalLibrary>> {
         let name_ptr = name.to_cstr();
-        let result = unsafe {
-            BNBinaryViewGetExternalLibrary(
-                self.as_ref().handle,
-                name_ptr.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result =
+            unsafe { BNBinaryViewGetExternalLibrary(self.as_ref().handle, name_ptr.as_ptr()) };
         let result_ptr = NonNull::new(result)?;
         Some(unsafe { ExternalLibrary::ref_from_raw(result_ptr) })
     }
 
     fn remove_external_library<S: AsCStr>(&self, name: S) {
         let name_ptr = name.to_cstr();
-        unsafe {
-            BNBinaryViewRemoveExternalLibrary(
-                self.as_ref().handle,
-                name_ptr.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        unsafe { BNBinaryViewRemoveExternalLibrary(self.as_ref().handle, name_ptr.as_ptr()) };
     }
 
     fn add_external_library<S: AsCStr>(
@@ -1549,7 +1499,7 @@ pub trait BinaryViewExt: BinaryViewBase {
         let result = unsafe {
             BNBinaryViewAddExternalLibrary(
                 self.as_ref().handle,
-                name_ptr.as_ref().as_ptr() as *const c_char,
+                name_ptr.as_ptr(),
                 backing_file
                     .map(|b| b.handle.as_ptr())
                     .unwrap_or(std::ptr::null_mut()),
@@ -1598,7 +1548,7 @@ pub trait BinaryViewExt: BinaryViewBase {
                 self.as_ref().handle,
                 symbol.handle,
                 library.handle.as_ptr(),
-                target_symbol_name.as_ref().as_ptr() as *const c_char,
+                target_symbol_name.as_ptr(),
                 target_address_ptr,
                 target_is_auto,
             )
@@ -1641,12 +1591,7 @@ pub trait BinaryViewExt: BinaryViewBase {
 
     fn type_library_by_name<S: AsCStr>(&self, name: S) -> Option<TypeLibrary> {
         let name = name.to_cstr();
-        let result = unsafe {
-            BNGetBinaryViewTypeLibrary(
-                self.as_ref().handle,
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNGetBinaryViewTypeLibrary(self.as_ref().handle, name.as_ptr()) };
         NonNull::new(result).map(|h| unsafe { TypeLibrary::from_raw(h) })
     }
 
@@ -1739,12 +1684,8 @@ pub trait BinaryViewExt: BinaryViewBase {
     ///     Dict[string_guid, Tuple[string_type_name, type_library_name]]
     fn import_type_by_guid<S: AsCStr>(&self, guid: S) -> Option<Ref<Type>> {
         let guid = guid.to_cstr();
-        let result = unsafe {
-            BNBinaryViewImportTypeLibraryTypeByGuid(
-                self.as_ref().handle,
-                guid.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result =
+            unsafe { BNBinaryViewImportTypeLibraryTypeByGuid(self.as_ref().handle, guid.as_ptr()) };
         (!result.is_null()).then(|| unsafe { Type::ref_from_raw(result) })
     }
 
diff --git a/rust/src/binary_view/memory_map.rs b/rust/src/binary_view/memory_map.rs
index b1737440..3afe0a20 100644
--- a/rust/src/binary_view/memory_map.rs
+++ b/rust/src/binary_view/memory_map.rs
@@ -5,7 +5,6 @@ use crate::rc::Ref;
 use crate::segment::SegmentFlags;
 use crate::string::{AsCStr, BnString};
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 
 #[derive(PartialEq, Eq, Hash)]
 pub struct MemoryMap {
@@ -52,7 +51,7 @@ impl MemoryMap {
         unsafe {
             BNAddBinaryMemoryRegion(
                 self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
                 start,
                 view.handle,
                 segment_flags.unwrap_or_default().into_raw(),
@@ -71,7 +70,7 @@ impl MemoryMap {
         unsafe {
             BNAddDataMemoryRegion(
                 self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
                 start,
                 data.as_raw(),
                 segment_flags.unwrap_or_default().into_raw(),
@@ -90,7 +89,7 @@ impl MemoryMap {
         unsafe {
             BNAddRemoteMemoryRegion(
                 self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
                 start,
                 &mut accessor.api_object,
                 segment_flags.unwrap_or_default().into_raw(),
@@ -100,12 +99,7 @@ impl MemoryMap {
 
     pub fn remove_memory_region(&mut self, name: impl AsCStr) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNRemoveMemoryRegion(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNRemoveMemoryRegion(self.view.handle, name_raw.as_ptr()) }
     }
 
     pub fn active_memory_region_at(&self, addr: u64) -> String {
@@ -117,88 +111,44 @@ impl MemoryMap {
 
     pub fn memory_region_flags(&self, name: impl AsCStr) -> SegmentFlags {
         let name_raw = name.to_cstr();
-        let flags_raw = unsafe {
-            BNGetMemoryRegionFlags(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let flags_raw = unsafe { BNGetMemoryRegionFlags(self.view.handle, name_raw.as_ptr()) };
         SegmentFlags::from_raw(flags_raw)
     }
 
     pub fn set_memory_region_flags(&mut self, name: impl AsCStr, flags: SegmentFlags) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNSetMemoryRegionFlags(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                flags.into_raw(),
-            )
-        }
+        unsafe { BNSetMemoryRegionFlags(self.view.handle, name_raw.as_ptr(), flags.into_raw()) }
     }
 
     pub fn is_memory_region_enabled(&self, name: impl AsCStr) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNIsMemoryRegionEnabled(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNIsMemoryRegionEnabled(self.view.handle, name_raw.as_ptr()) }
     }
 
     pub fn set_memory_region_enabled(&mut self, name: impl AsCStr, enabled: bool) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNSetMemoryRegionEnabled(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                enabled,
-            )
-        }
+        unsafe { BNSetMemoryRegionEnabled(self.view.handle, name_raw.as_ptr(), enabled) }
     }
 
     // TODO: Should we just call this is_memory_region_relocatable?
     pub fn is_memory_region_rebaseable(&self, name: impl AsCStr) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNIsMemoryRegionRebaseable(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNIsMemoryRegionRebaseable(self.view.handle, name_raw.as_ptr()) }
     }
 
     pub fn set_memory_region_rebaseable(&mut self, name: impl AsCStr, enabled: bool) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNSetMemoryRegionRebaseable(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                enabled,
-            )
-        }
+        unsafe { BNSetMemoryRegionRebaseable(self.view.handle, name_raw.as_ptr(), enabled) }
     }
 
     pub fn memory_region_fill(&self, name: impl AsCStr) -> u8 {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNGetMemoryRegionFill(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNGetMemoryRegionFill(self.view.handle, name_raw.as_ptr()) }
     }
 
     pub fn set_memory_region_fill(&mut self, name: impl AsCStr, fill: u8) -> bool {
         let name_raw = name.to_cstr();
-        unsafe {
-            BNSetMemoryRegionFill(
-                self.view.handle,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                fill,
-            )
-        }
+        unsafe { BNSetMemoryRegionFill(self.view.handle, name_raw.as_ptr(), fill) }
     }
 
     pub fn reset(&mut self) {
diff --git a/rust/src/calling_convention.rs b/rust/src/calling_convention.rs
index f0f0ba4c..7db61d8a 100644
--- a/rust/src/calling_convention.rs
+++ b/rust/src/calling_convention.rs
@@ -413,7 +413,7 @@ where
     };
 
     unsafe {
-        let cc_name = name.as_ref().as_ptr() as *mut _;
+        let cc_name = name.as_ptr();
         let result = BNCreateCallingConvention(arch.as_ref().handle, cc_name, &mut cc);
 
         assert!(!result.is_null());
diff --git a/rust/src/collaboration.rs b/rust/src/collaboration.rs
index 1f76dc9a..8a1774f2 100644
--- a/rust/src/collaboration.rs
+++ b/rust/src/collaboration.rs
@@ -75,22 +75,21 @@ pub fn known_remotes() -> Array<Remote> {
 /// Get Remote by unique `id`
 pub fn get_remote_by_id<S: AsCStr>(id: S) -> Option<Ref<Remote>> {
     let id = id.to_cstr();
-    let value = unsafe { BNCollaborationGetRemoteById(id.as_ref().as_ptr() as *const c_char) };
+    let value = unsafe { BNCollaborationGetRemoteById(id.as_ptr()) };
     NonNull::new(value).map(|h| unsafe { Remote::ref_from_raw(h) })
 }
 
 /// Get Remote by `address`
 pub fn get_remote_by_address<S: AsCStr>(address: S) -> Option<Ref<Remote>> {
     let address = address.to_cstr();
-    let value =
-        unsafe { BNCollaborationGetRemoteByAddress(address.as_ref().as_ptr() as *const c_char) };
+    let value = unsafe { BNCollaborationGetRemoteByAddress(address.as_ptr()) };
     NonNull::new(value).map(|h| unsafe { Remote::ref_from_raw(h) })
 }
 
 /// Get Remote by `name`
 pub fn get_remote_by_name<S: AsCStr>(name: S) -> Option<Ref<Remote>> {
     let name = name.to_cstr();
-    let value = unsafe { BNCollaborationGetRemoteByName(name.as_ref().as_ptr() as *const c_char) };
+    let value = unsafe { BNCollaborationGetRemoteByName(name.as_ptr()) };
     NonNull::new(value).map(|h| unsafe { Remote::ref_from_raw(h) })
 }
 
@@ -116,17 +115,11 @@ where
         .into_iter()
         .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
         .unzip();
-    let data_keys_ptr: Box<[*const c_char]> = data_keys
-        .iter()
-        .map(|k| k.as_ref().as_ptr() as *const c_char)
-        .collect();
-    let data_values_ptr: Box<[*const c_char]> = data_values
-        .iter()
-        .map(|v| v.as_ref().as_ptr() as *const c_char)
-        .collect();
+    let data_keys_ptr: Box<[*const c_char]> = data_keys.iter().map(|k| k.as_ptr()).collect();
+    let data_values_ptr: Box<[*const c_char]> = data_values.iter().map(|v| v.as_ptr()).collect();
     unsafe {
         BNCollaborationStoreDataInKeychain(
-            key.as_ref().as_ptr() as *const c_char,
+            key.as_ptr(),
             data_keys_ptr.as_ptr() as *mut _,
             data_values_ptr.as_ptr() as *mut _,
             data_keys.len(),
@@ -136,20 +129,14 @@ where
 
 pub fn has_data_in_keychain<K: AsCStr>(key: K) -> bool {
     let key = key.to_cstr();
-    unsafe { BNCollaborationHasDataInKeychain(key.as_ref().as_ptr() as *const c_char) }
+    unsafe { BNCollaborationHasDataInKeychain(key.as_ptr()) }
 }
 
 pub fn get_data_from_keychain<K: AsCStr>(key: K) -> Option<(Array<BnString>, Array<BnString>)> {
     let key = key.to_cstr();
     let mut keys = std::ptr::null_mut();
     let mut values = std::ptr::null_mut();
-    let count = unsafe {
-        BNCollaborationGetDataFromKeychain(
-            key.as_ref().as_ptr() as *const c_char,
-            &mut keys,
-            &mut values,
-        )
-    };
+    let count = unsafe { BNCollaborationGetDataFromKeychain(key.as_ptr(), &mut keys, &mut values) };
     let keys = (!keys.is_null()).then(|| unsafe { Array::new(keys, count, ()) });
     let values = (!values.is_null()).then(|| unsafe { Array::new(values, count, ()) });
     keys.zip(values)
@@ -157,5 +144,5 @@ pub fn get_data_from_keychain<K: AsCStr>(key: K) -> Option<(Array<BnString>, Arr
 
 pub fn delete_data_from_keychain<K: AsCStr>(key: K) -> bool {
     let key = key.to_cstr();
-    unsafe { BNCollaborationDeleteDataFromKeychain(key.as_ref().as_ptr() as *const c_char) }
+    unsafe { BNCollaborationDeleteDataFromKeychain(key.as_ptr()) }
 }
diff --git a/rust/src/collaboration/changeset.rs b/rust/src/collaboration/changeset.rs
index 1cc30d76..0db384cb 100644
--- a/rust/src/collaboration/changeset.rs
+++ b/rust/src/collaboration/changeset.rs
@@ -1,5 +1,4 @@
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::ptr::NonNull;
 
 use super::{RemoteFile, RemoteUser};
@@ -68,12 +67,7 @@ impl Changeset {
     /// Set the name of the changeset, e.g. in a name changeset function.
     pub fn set_name<S: AsCStr>(&self, value: S) -> bool {
         let value = value.to_cstr();
-        unsafe {
-            BNCollaborationChangesetSetName(
-                self.handle.as_ptr(),
-                value.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNCollaborationChangesetSetName(self.handle.as_ptr(), value.as_ptr()) }
     }
 }
 
diff --git a/rust/src/collaboration/file.rs b/rust/src/collaboration/file.rs
index 2089fbb7..251b4f7d 100644
--- a/rust/src/collaboration/file.rs
+++ b/rust/src/collaboration/file.rs
@@ -1,4 +1,4 @@
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::fmt::{Debug, Formatter};
 use std::ptr::NonNull;
 use std::time::SystemTime;
@@ -96,12 +96,7 @@ impl RemoteFile {
 
     pub fn set_metadata<S: AsCStr>(&self, folder: S) -> Result<(), ()> {
         let folder_raw = folder.to_cstr();
-        let success = unsafe {
-            BNRemoteFileSetMetadata(
-                self.handle.as_ptr(),
-                folder_raw.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success = unsafe { BNRemoteFileSetMetadata(self.handle.as_ptr(), folder_raw.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -192,12 +187,7 @@ impl RemoteFile {
     /// Set the description of the file. You will need to push the file to update the remote version.
     pub fn set_name<S: AsCStr>(&self, name: S) -> Result<(), ()> {
         let name = name.to_cstr();
-        let success = unsafe {
-            BNRemoteFileSetName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success = unsafe { BNRemoteFileSetName(self.handle.as_ptr(), name.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -211,12 +201,8 @@ impl RemoteFile {
     /// Set the description of the file. You will need to push the file to update the remote version.
     pub fn set_description<S: AsCStr>(&self, description: S) -> Result<(), ()> {
         let description = description.to_cstr();
-        let success = unsafe {
-            BNRemoteFileSetDescription(
-                self.handle.as_ptr(),
-                description.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success =
+            unsafe { BNRemoteFileSetDescription(self.handle.as_ptr(), description.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -269,9 +255,7 @@ impl RemoteFile {
             self.pull_snapshots()?;
         }
         let id = id.to_cstr();
-        let result = unsafe {
-            BNRemoteFileGetSnapshotById(self.handle.as_ptr(), id.as_ref().as_ptr() as *const c_char)
-        };
+        let result = unsafe { BNRemoteFileGetSnapshotById(self.handle.as_ptr(), id.as_ptr()) };
         Ok(NonNull::new(result).map(|handle| unsafe { RemoteSnapshot::ref_from_raw(handle) }))
     }
 
@@ -350,14 +334,11 @@ impl RemoteFile {
     {
         let name = name.to_cstr();
         let parent_ids: Vec<_> = parent_ids.into_iter().map(|id| id.to_cstr()).collect();
-        let mut parent_ids_raw: Vec<_> = parent_ids
-            .iter()
-            .map(|x| x.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut parent_ids_raw: Vec<_> = parent_ids.iter().map(|x| x.as_ptr()).collect();
         let result = unsafe {
             BNRemoteFileCreateSnapshot(
                 self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
+                name.as_ptr(),
                 contents.as_mut_ptr(),
                 contents.len(),
                 analysis_cache_contexts.as_mut_ptr(),
diff --git a/rust/src/collaboration/folder.rs b/rust/src/collaboration/folder.rs
index 0fd2bf87..b5fde3b4 100644
--- a/rust/src/collaboration/folder.rs
+++ b/rust/src/collaboration/folder.rs
@@ -1,6 +1,5 @@
 use super::{Remote, RemoteProject};
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::ptr::NonNull;
 
 use crate::project::folder::ProjectFolder;
@@ -106,12 +105,7 @@ impl RemoteFolder {
     /// Set the display name of the folder. You will need to push the folder to update the remote version.
     pub fn set_name<S: AsCStr>(&self, name: S) -> Result<(), ()> {
         let name = name.to_cstr();
-        let success = unsafe {
-            BNRemoteFolderSetName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success = unsafe { BNRemoteFolderSetName(self.handle.as_ptr(), name.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -125,12 +119,8 @@ impl RemoteFolder {
     /// Set the description of the folder. You will need to push the folder to update the remote version.
     pub fn set_description<S: AsCStr>(&self, description: S) -> Result<(), ()> {
         let description = description.to_cstr();
-        let success = unsafe {
-            BNRemoteFolderSetDescription(
-                self.handle.as_ptr(),
-                description.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success =
+            unsafe { BNRemoteFolderSetDescription(self.handle.as_ptr(), description.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 }
diff --git a/rust/src/collaboration/group.rs b/rust/src/collaboration/group.rs
index 94253519..b8b32c7a 100644
--- a/rust/src/collaboration/group.rs
+++ b/rust/src/collaboration/group.rs
@@ -2,7 +2,6 @@ use super::Remote;
 use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner, Guard, Ref, RefCountable};
 use crate::string::{AsCStr, BnString};
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::fmt;
 use std::fmt::{Display, Formatter};
 use std::ptr::NonNull;
@@ -52,12 +51,7 @@ impl RemoteGroup {
     /// You will need to push the group to update the Remote.
     pub fn set_name<U: AsCStr>(&self, name: U) {
         let name = name.to_cstr();
-        unsafe {
-            BNCollaborationGroupSetName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNCollaborationGroupSetName(self.handle.as_ptr(), name.as_ptr()) }
     }
 
     /// Get list of users in the group
@@ -93,10 +87,7 @@ impl RemoteGroup {
         I::Item: AsCStr,
     {
         let usernames: Vec<_> = usernames.into_iter().map(|u| u.to_cstr()).collect();
-        let mut usernames_raw: Vec<_> = usernames
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut usernames_raw: Vec<_> = usernames.iter().map(|s| s.as_ptr()).collect();
         // TODO: This should only fail if collaboration is not supported.
         // TODO: Because you should not have a RemoteGroup at that point we can ignore?
         // TODO: Do you need any permissions to do this?
@@ -113,12 +104,7 @@ impl RemoteGroup {
     /// Test if a group has a user with the given username
     pub fn contains_user<U: AsCStr>(&self, username: U) -> bool {
         let username = username.to_cstr();
-        unsafe {
-            BNCollaborationGroupContainsUser(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNCollaborationGroupContainsUser(self.handle.as_ptr(), username.as_ptr()) }
     }
 }
 
diff --git a/rust/src/collaboration/merge.rs b/rust/src/collaboration/merge.rs
index 84aa6192..2fb5b3de 100644
--- a/rust/src/collaboration/merge.rs
+++ b/rust/src/collaboration/merge.rs
@@ -1,5 +1,4 @@
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::ptr::NonNull;
 
 use crate::database::{snapshot::Snapshot, Database};
@@ -52,10 +51,7 @@ impl MergeConflict {
     pub fn path_item_string<S: AsCStr>(&self, path: S) -> Result<BnString, ()> {
         let path = path.to_cstr();
         let result = unsafe {
-            BNAnalysisMergeConflictGetPathItemString(
-                self.handle.as_ptr(),
-                path.as_ref().as_ptr() as *const c_char,
-            )
+            BNAnalysisMergeConflictGetPathItemString(self.handle.as_ptr(), path.as_ptr())
         };
         (!result.is_null())
             .then(|| unsafe { BnString::from_raw(result) })
@@ -125,24 +121,16 @@ impl MergeConflict {
     /// Call this when you've resolved the conflict to save the result
     pub fn success<S: AsCStr>(&self, value: S) -> Result<(), ()> {
         let value = value.to_cstr();
-        let success = unsafe {
-            BNAnalysisMergeConflictSuccess(
-                self.handle.as_ptr(),
-                value.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success =
+            unsafe { BNAnalysisMergeConflictSuccess(self.handle.as_ptr(), value.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
     // TODO: Make a safe version of this that checks the path and if it holds a number
     pub unsafe fn get_path_item_number<S: AsCStr>(&self, path_key: S) -> Option<u64> {
         let path_key = path_key.to_cstr();
-        let value = unsafe {
-            BNAnalysisMergeConflictGetPathItem(
-                self.handle.as_ptr(),
-                path_key.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let value =
+            unsafe { BNAnalysisMergeConflictGetPathItem(self.handle.as_ptr(), path_key.as_ptr()) };
         match value.is_null() {
             // SAFETY: The path must be a number.
             false => Some(value as u64),
@@ -153,10 +141,7 @@ impl MergeConflict {
     pub unsafe fn get_path_item_string<S: AsCStr>(&self, path_key: S) -> Option<BnString> {
         let path_key = path_key.to_cstr();
         let value = unsafe {
-            BNAnalysisMergeConflictGetPathItemString(
-                self.handle.as_ptr(),
-                path_key.as_ref().as_ptr() as *const c_char,
-            )
+            BNAnalysisMergeConflictGetPathItemString(self.handle.as_ptr(), path_key.as_ptr())
         };
         match value.is_null() {
             false => Some(unsafe { BnString::from_raw(value) }),
diff --git a/rust/src/collaboration/project.rs b/rust/src/collaboration/project.rs
index 8c04080b..fce2a5f6 100644
--- a/rust/src/collaboration/project.rs
+++ b/rust/src/collaboration/project.rs
@@ -1,4 +1,4 @@
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::ptr::NonNull;
 use std::time::SystemTime;
 
@@ -138,12 +138,7 @@ impl RemoteProject {
     /// Set the description of the file. You will need to push the file to update the remote version.
     pub fn set_name<S: AsCStr>(&self, name: S) -> Result<(), ()> {
         let name = name.to_cstr();
-        let success = unsafe {
-            BNRemoteProjectSetName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success = unsafe { BNRemoteProjectSetName(self.handle.as_ptr(), name.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -157,12 +152,8 @@ impl RemoteProject {
     /// Set the description of the file. You will need to push the file to update the remote version.
     pub fn set_description<S: AsCStr>(&self, description: S) -> Result<(), ()> {
         let description = description.to_cstr();
-        let success = unsafe {
-            BNRemoteProjectSetDescription(
-                self.handle.as_ptr(),
-                description.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let success =
+            unsafe { BNRemoteProjectSetDescription(self.handle.as_ptr(), description.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -236,9 +227,7 @@ impl RemoteProject {
             self.pull_files()?;
         }
         let id = id.to_cstr();
-        let result = unsafe {
-            BNRemoteProjectGetFileById(self.handle.as_ptr(), id.as_ref().as_ptr() as *const c_char)
-        };
+        let result = unsafe { BNRemoteProjectGetFileById(self.handle.as_ptr(), id.as_ptr()) };
         Ok(NonNull::new(result).map(|handle| unsafe { RemoteFile::ref_from_raw(handle) }))
     }
 
@@ -252,12 +241,7 @@ impl RemoteProject {
             self.pull_files()?;
         }
         let id = name.to_cstr();
-        let result = unsafe {
-            BNRemoteProjectGetFileByName(
-                self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNRemoteProjectGetFileByName(self.handle.as_ptr(), id.as_ptr()) };
         Ok(NonNull::new(result).map(|handle| unsafe { RemoteFile::ref_from_raw(handle) }))
     }
 
@@ -360,11 +344,11 @@ impl RemoteProject {
         let file_ptr = unsafe {
             BNRemoteProjectCreateFile(
                 self.handle.as_ptr(),
-                filename.as_ref().as_ptr() as *const c_char,
+                filename.as_ptr(),
                 contents.as_ptr() as *mut _,
                 contents.len(),
-                name.as_ref().as_ptr() as *const c_char,
-                description.as_ref().as_ptr() as *const c_char,
+                name.as_ptr(),
+                description.as_ptr(),
                 folder_handle,
                 file_type,
                 Some(P::cb_progress_callback),
@@ -393,14 +377,8 @@ impl RemoteProject {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let mut keys_raw = keys
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
-        let mut values_raw = values
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
+        let mut keys_raw = keys.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+        let mut values_raw = values.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
         let success = unsafe {
             BNRemoteProjectPushFile(
                 self.handle.as_ptr(),
@@ -449,12 +427,7 @@ impl RemoteProject {
             self.pull_folders()?;
         }
         let id = id.to_cstr();
-        let result = unsafe {
-            BNRemoteProjectGetFolderById(
-                self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNRemoteProjectGetFolderById(self.handle.as_ptr(), id.as_ptr()) };
         Ok(NonNull::new(result).map(|handle| unsafe { RemoteFolder::ref_from_raw(handle) }))
     }
 
@@ -534,8 +507,8 @@ impl RemoteProject {
         let file_ptr = unsafe {
             BNRemoteProjectCreateFolder(
                 self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-                description.as_ref().as_ptr() as *const c_char,
+                name.as_ptr(),
+                description.as_ptr(),
                 folder_handle,
                 Some(P::cb_progress_callback),
                 &mut progress as *mut P as *mut c_void,
@@ -566,14 +539,8 @@ impl RemoteProject {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let mut keys_raw = keys
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
-        let mut values_raw = values
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
+        let mut keys_raw = keys.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+        let mut values_raw = values.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
         let success = unsafe {
             BNRemoteProjectPushFolder(
                 self.handle.as_ptr(),
@@ -761,7 +728,7 @@ impl RemoteProject {
         let value = unsafe {
             BNRemoteProjectCreateUserPermission(
                 self.handle.as_ptr(),
-                user_id.as_ref().as_ptr() as *const c_char,
+                user_id.as_ptr(),
                 level,
                 Some(F::cb_progress_callback),
                 &mut progress as *mut F as *mut c_void,
@@ -793,14 +760,8 @@ impl RemoteProject {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let mut keys_raw = keys
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
-        let mut values_raw = values
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
+        let mut keys_raw = keys.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+        let mut values_raw = values.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
 
         let success = unsafe {
             BNRemoteProjectPushPermission(
@@ -829,12 +790,7 @@ impl RemoteProject {
     /// * `username` - Username of user to check
     pub fn can_user_view<S: AsCStr>(&self, username: S) -> bool {
         let username = username.to_cstr();
-        unsafe {
-            BNRemoteProjectCanUserView(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNRemoteProjectCanUserView(self.handle.as_ptr(), username.as_ptr()) }
     }
 
     /// Determine if a user is in any of the edit/admin groups.
@@ -844,12 +800,7 @@ impl RemoteProject {
     /// * `username` - Username of user to check
     pub fn can_user_edit<S: AsCStr>(&self, username: S) -> bool {
         let username = username.to_cstr();
-        unsafe {
-            BNRemoteProjectCanUserEdit(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNRemoteProjectCanUserEdit(self.handle.as_ptr(), username.as_ptr()) }
     }
 
     /// Determine if a user is in the admin group.
@@ -859,12 +810,7 @@ impl RemoteProject {
     /// * `username` - Username of user to check
     pub fn can_user_admin<S: AsCStr>(&self, username: S) -> bool {
         let username = username.to_cstr();
-        unsafe {
-            BNRemoteProjectCanUserAdmin(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNRemoteProjectCanUserAdmin(self.handle.as_ptr(), username.as_ptr()) }
     }
 
     /// Get the default directory path for a remote Project. This is based off
diff --git a/rust/src/collaboration/remote.rs b/rust/src/collaboration/remote.rs
index 3a1f021c..ee37e9fb 100644
--- a/rust/src/collaboration/remote.rs
+++ b/rust/src/collaboration/remote.rs
@@ -1,5 +1,5 @@
 use binaryninjacore_sys::*;
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::ptr::NonNull;
 
 use super::{sync, GroupId, RemoteGroup, RemoteProject, RemoteUser};
@@ -30,12 +30,7 @@ impl Remote {
     pub fn new<N: AsCStr, A: AsCStr>(name: N, address: A) -> Ref<Self> {
         let name = name.to_cstr();
         let address = address.to_cstr();
-        let result = unsafe {
-            BNCollaborationCreateRemote(
-                name.as_ref().as_ptr() as *const c_char,
-                address.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNCollaborationCreateRemote(name.as_ptr(), address.as_ptr()) };
         unsafe { Self::ref_from_raw(NonNull::new(result).unwrap()) }
     }
 
@@ -178,8 +173,8 @@ impl Remote {
         let token = unsafe {
             BNRemoteRequestAuthenticationToken(
                 self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-                password.as_ref().as_ptr() as *const c_char,
+                username.as_ptr(),
+                password.as_ptr(),
             )
         };
         if token.is_null() {
@@ -230,10 +225,8 @@ impl Remote {
             }
         };
         let username = options.username.to_cstr();
-        let username_ptr = username.as_ptr() as *const c_char;
         let token = token.to_cstr();
-        let token_ptr = token.as_ptr() as *const c_char;
-        let success = unsafe { BNRemoteConnect(self.handle.as_ptr(), username_ptr, token_ptr) };
+        let success = unsafe { BNRemoteConnect(self.handle.as_ptr(), username.as_ptr(), token.as_ptr()) };
         success.then_some(()).ok_or(())
     }
 
@@ -287,9 +280,7 @@ impl Remote {
         }
 
         let id = id.to_cstr();
-        let value = unsafe {
-            BNRemoteGetProjectById(self.handle.as_ptr(), id.as_ref().as_ptr() as *const c_char)
-        };
+        let value = unsafe { BNRemoteGetProjectById(self.handle.as_ptr(), id.as_ptr()) };
         Ok(NonNull::new(value).map(|handle| unsafe { RemoteProject::ref_from_raw(handle) }))
     }
 
@@ -305,12 +296,7 @@ impl Remote {
         }
 
         let name = name.to_cstr();
-        let value = unsafe {
-            BNRemoteGetProjectByName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let value = unsafe { BNRemoteGetProjectByName(self.handle.as_ptr(), name.as_ptr()) };
         Ok(NonNull::new(value).map(|handle| unsafe { RemoteProject::ref_from_raw(handle) }))
     }
 
@@ -358,11 +344,7 @@ impl Remote {
         let name = name.to_cstr();
         let description = description.to_cstr();
         let value = unsafe {
-            BNRemoteCreateProject(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-                description.as_ref().as_ptr() as *const c_char,
-            )
+            BNRemoteCreateProject(self.handle.as_ptr(), name.as_ptr(), description.as_ptr())
         };
         NonNull::new(value)
             .map(|handle| unsafe { RemoteProject::ref_from_raw(handle) })
@@ -407,14 +389,8 @@ impl Remote {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let mut keys_raw = keys
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
-        let mut values_raw = values
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect::<Vec<_>>();
+        let mut keys_raw = keys.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+        let mut values_raw = values.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
 
         let success = unsafe {
             BNRemotePushProject(
@@ -475,12 +451,7 @@ impl Remote {
         }
 
         let name = name.to_cstr();
-        let value = unsafe {
-            BNRemoteGetGroupByName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let value = unsafe { BNRemoteGetGroupByName(self.handle.as_ptr(), name.as_ptr()) };
 
         Ok(NonNull::new(value).map(|handle| unsafe { RemoteGroup::ref_from_raw(handle) }))
     }
@@ -502,7 +473,7 @@ impl Remote {
         let success = unsafe {
             BNRemoteSearchGroups(
                 self.handle.as_ptr(),
-                prefix.as_ref().as_ptr() as *const c_char,
+                prefix.as_ptr(),
                 &mut group_ids,
                 &mut group_names,
                 &mut count,
@@ -560,15 +531,12 @@ impl Remote {
     {
         let name = name.to_cstr();
         let usernames: Vec<_> = usernames.into_iter().map(|s| s.to_cstr()).collect();
-        let mut username_ptrs: Vec<_> = usernames
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut username_ptrs: Vec<_> = usernames.iter().map(|s| s.as_ptr()).collect();
 
         let value = unsafe {
             BNRemoteCreateGroup(
                 self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
+                name.as_ptr(),
                 username_ptrs.as_mut_ptr(),
                 username_ptrs.len(),
             )
@@ -595,14 +563,8 @@ impl Remote {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let mut keys_raw: Vec<_> = keys
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
-        let mut values_raw: Vec<_> = values
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut keys_raw: Vec<_> = keys.iter().map(|s| s.as_ptr()).collect();
+        let mut values_raw: Vec<_> = values.iter().map(|s| s.as_ptr()).collect();
 
         let success = unsafe {
             BNRemotePushGroup(
@@ -659,9 +621,7 @@ impl Remote {
             self.pull_users()?;
         }
         let id = id.to_cstr();
-        let value = unsafe {
-            BNRemoteGetUserById(self.handle.as_ptr(), id.as_ref().as_ptr() as *const c_char)
-        };
+        let value = unsafe { BNRemoteGetUserById(self.handle.as_ptr(), id.as_ptr()) };
         Ok(NonNull::new(value).map(|handle| unsafe { RemoteUser::ref_from_raw(handle) }))
     }
 
@@ -682,12 +642,7 @@ impl Remote {
             self.pull_users()?;
         }
         let username = username.to_cstr();
-        let value = unsafe {
-            BNRemoteGetUserByUsername(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let value = unsafe { BNRemoteGetUserByUsername(self.handle.as_ptr(), username.as_ptr()) };
         Ok(NonNull::new(value).map(|handle| unsafe { RemoteUser::ref_from_raw(handle) }))
     }
 
@@ -720,7 +675,7 @@ impl Remote {
         let success = unsafe {
             BNRemoteSearchUsers(
                 self.handle.as_ptr(),
-                prefix.as_ref().as_ptr() as *const c_char,
+                prefix.as_ptr(),
                 &mut user_ids,
                 &mut usernames,
                 &mut count,
@@ -790,10 +745,10 @@ impl Remote {
         let value = unsafe {
             BNRemoteCreateUser(
                 self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-                email.as_ref().as_ptr() as *const c_char,
+                username.as_ptr(),
+                email.as_ptr(),
                 is_active,
-                password.as_ref().as_ptr() as *const c_char,
+                password.as_ptr(),
                 group_ids.as_ptr(),
                 group_ids.len(),
                 user_permission_ids.as_ptr(),
@@ -823,14 +778,8 @@ impl Remote {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let mut keys_raw: Vec<_> = keys
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
-        let mut values_raw: Vec<_> = values
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut keys_raw: Vec<_> = keys.iter().map(|s| s.as_ptr()).collect();
+        let mut values_raw: Vec<_> = values.iter().map(|s| s.as_ptr()).collect();
         let success = unsafe {
             BNRemotePushUser(
                 self.handle.as_ptr(),
diff --git a/rust/src/collaboration/snapshot.rs b/rust/src/collaboration/snapshot.rs
index 465ae46a..6e1dfb89 100644
--- a/rust/src/collaboration/snapshot.rs
+++ b/rust/src/collaboration/snapshot.rs
@@ -1,4 +1,4 @@
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::ptr::NonNull;
 use std::time::SystemTime;
 
@@ -237,7 +237,7 @@ impl RemoteSnapshot {
                 self.handle.as_ptr(),
                 parent.is_some(),
                 parent.unwrap_or(0),
-                data.as_ref().as_ptr() as *const c_char,
+                data.as_ptr(),
             )
         };
         let handle = NonNull::new(value).ok_or(())?;
diff --git a/rust/src/collaboration/sync.rs b/rust/src/collaboration/sync.rs
index 4c112336..5afb8923 100644
--- a/rust/src/collaboration/sync.rs
+++ b/rust/src/collaboration/sync.rs
@@ -63,7 +63,7 @@ pub fn download_file_with_progress<S: AsCStr, F: ProgressCallback>(
     let result = unsafe {
         BNCollaborationDownloadFile(
             file.handle.as_ptr(),
-            db_path.as_ref().as_ptr() as *const c_char,
+            db_path.as_ptr(),
             Some(F::cb_progress_callback),
             &mut progress as *mut F as *mut c_void,
         )
@@ -239,7 +239,7 @@ where
     let success = unsafe {
         BNCollaborationDownloadDatabaseForFile(
             file.handle.as_ptr(),
-            db_path.as_ref().as_ptr() as *const c_char,
+            db_path.as_ptr(),
             force,
             Some(F::cb_progress_callback),
             &mut progress as *mut _ as *mut c_void,
@@ -485,7 +485,7 @@ pub fn set_snapshot_author<S: AsCStr>(
         BNCollaborationSetSnapshotAuthor(
             database.handle.as_ptr(),
             snapshot.handle.as_ptr(),
-            author.as_ref().as_ptr() as *const c_char,
+            author.as_ptr(),
         )
     };
     success.then_some(()).ok_or(())
@@ -658,7 +658,7 @@ pub fn get_remote_snapshot_from_local_type_archive<S: AsCStr>(
     let value = unsafe {
         BNCollaborationGetRemoteSnapshotFromLocalTypeArchive(
             type_archive.handle.as_ptr(),
-            snapshot_id.as_ref().as_ptr() as *const c_char,
+            snapshot_id.as_ptr(),
         )
     };
     NonNull::new(value).map(|handle| unsafe { RemoteSnapshot::ref_from_raw(handle) })
@@ -687,7 +687,7 @@ pub fn is_type_archive_snapshot_ignored<S: AsCStr>(
     unsafe {
         BNCollaborationIsTypeArchiveSnapshotIgnored(
             type_archive.handle.as_ptr(),
-            snapshot_id.as_ref().as_ptr() as *const c_char,
+            snapshot_id.as_ptr(),
         )
     }
 }
@@ -713,7 +713,7 @@ pub fn download_type_archive_with_progress<S: AsCStr, F: ProgressCallback>(
     let success = unsafe {
         BNCollaborationDownloadTypeArchive(
             file.handle.as_ptr(),
-            db_path.as_ref().as_ptr() as *const c_char,
+            db_path.as_ptr(),
             Some(F::cb_progress_callback),
             &mut progress as *mut F as *mut c_void,
             &mut value,
diff --git a/rust/src/collaboration/user.rs b/rust/src/collaboration/user.rs
index 43b4e854..d4aea2c5 100644
--- a/rust/src/collaboration/user.rs
+++ b/rust/src/collaboration/user.rs
@@ -1,6 +1,5 @@
 use super::Remote;
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::ptr::NonNull;
 
 use crate::rc::{CoreArrayProvider, CoreArrayProviderInner, Guard, Ref, RefCountable};
@@ -51,12 +50,8 @@ impl RemoteUser {
     /// Set user's username. You will need to push the user to update the Remote
     pub fn set_username<U: AsCStr>(&self, username: U) -> Result<(), ()> {
         let username = username.to_cstr();
-        let result = unsafe {
-            BNCollaborationUserSetUsername(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result =
+            unsafe { BNCollaborationUserSetUsername(self.handle.as_ptr(), username.as_ptr()) };
         if result {
             Ok(())
         } else {
@@ -74,12 +69,8 @@ impl RemoteUser {
     /// Set user's email. You will need to push the user to update the Remote
     pub fn set_email<U: AsCStr>(&self, email: U) -> Result<(), ()> {
         let username = email.to_cstr();
-        let result = unsafe {
-            BNCollaborationUserSetEmail(
-                self.handle.as_ptr(),
-                username.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result =
+            unsafe { BNCollaborationUserSetEmail(self.handle.as_ptr(), username.as_ptr()) };
         if result {
             Ok(())
         } else {
diff --git a/rust/src/command.rs b/rust/src/command.rs
index 0297d6cf..721f9170 100644
--- a/rust/src/command.rs
+++ b/rust/src/command.rs
@@ -129,8 +129,8 @@ where
     let name = name.to_cstr();
     let desc = desc.to_cstr();
 
-    let name_ptr = name.as_ref().as_ptr() as *mut _;
-    let desc_ptr = desc.as_ref().as_ptr() as *mut _;
+    let name_ptr = name.as_ptr();
+    let desc_ptr = desc.as_ptr();
 
     let ctxt = Box::into_raw(Box::new(command));
 
@@ -230,8 +230,8 @@ where
     let name = name.to_cstr();
     let desc = desc.to_cstr();
 
-    let name_ptr = name.as_ref().as_ptr() as *mut _;
-    let desc_ptr = desc.as_ref().as_ptr() as *mut _;
+    let name_ptr = name.as_ptr();
+    let desc_ptr = desc.as_ptr();
 
     let ctxt = Box::into_raw(Box::new(command));
 
@@ -337,8 +337,8 @@ where
     let name = name.to_cstr();
     let desc = desc.to_cstr();
 
-    let name_ptr = name.as_ref().as_ptr() as *mut _;
-    let desc_ptr = desc.as_ref().as_ptr() as *mut _;
+    let name_ptr = name.as_ptr();
+    let desc_ptr = desc.as_ptr();
 
     let ctxt = Box::into_raw(Box::new(command));
 
@@ -449,8 +449,8 @@ where
     let name = name.to_cstr();
     let desc = desc.to_cstr();
 
-    let name_ptr = name.as_ref().as_ptr() as *mut _;
-    let desc_ptr = desc.as_ref().as_ptr() as *mut _;
+    let name_ptr = name.as_ptr();
+    let desc_ptr = desc.as_ptr();
 
     let ctxt = Box::into_raw(Box::new(command));
 
diff --git a/rust/src/component.rs b/rust/src/component.rs
index 5fe44b64..48c8b110 100644
--- a/rust/src/component.rs
+++ b/rust/src/component.rs
@@ -166,12 +166,7 @@ impl Component {
 
     pub fn set_name<S: AsCStr>(&self, name: S) {
         let name = name.to_cstr();
-        unsafe {
-            BNComponentSetName(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNComponentSetName(self.handle.as_ptr(), name.as_ptr()) }
     }
 
     /// The component that contains this component, if it exists.
diff --git a/rust/src/custom_binary_view.rs b/rust/src/custom_binary_view.rs
index adcde09d..ee32a67f 100644
--- a/rust/src/custom_binary_view.rs
+++ b/rust/src/custom_binary_view.rs
@@ -15,7 +15,6 @@
 //! An interface for providing your own [BinaryView]s to Binary Ninja.
 
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 
 pub use binaryninjacore_sys::BNModificationStatus as ModificationStatus;
 
@@ -150,10 +149,10 @@ where
     }
 
     let name = name.to_cstr();
-    let name_ptr = name.as_ref().as_ptr() as *mut _;
+    let name_ptr = name.as_ptr();
 
     let long_name = long_name.to_cstr();
-    let long_name_ptr = long_name.as_ref().as_ptr() as *mut _;
+    let long_name_ptr = long_name.as_ptr();
 
     let ctxt = Box::leak(Box::new(MaybeUninit::zeroed()));
 
@@ -878,9 +877,10 @@ impl<'a, T: CustomBinaryViewType> CustomViewBuilder<'a, T> {
             save: Some(cb_save::<V>),
         };
 
+        let view_name = view_name.to_cstr();
         unsafe {
             let res = BNCreateCustomBinaryView(
-                view_name.as_ptr() as *const c_char,
+                view_name.as_ptr(),
                 file.handle,
                 parent.handle,
                 &mut bn_obj,
diff --git a/rust/src/database.rs b/rust/src/database.rs
index fd20d173..d01839d2 100644
--- a/rust/src/database.rs
+++ b/rust/src/database.rs
@@ -4,7 +4,7 @@ pub mod undo;
 
 use binaryninjacore_sys::*;
 use std::collections::HashMap;
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::fmt::Debug;
 use std::ptr::NonNull;
 
@@ -94,7 +94,7 @@ impl Database {
         P: ProgressCallback,
     {
         let name_raw = name.to_cstr();
-        let name_ptr = name_raw.as_ref().as_ptr() as *const c_char;
+        let name_ptr = name_raw.as_ptr();
 
         let new_id = unsafe {
             BNWriteDatabaseSnapshotData(
@@ -135,8 +135,7 @@ impl Database {
     }
     pub fn has_global<S: AsCStr>(&self, key: S) -> bool {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
-        unsafe { BNDatabaseHasGlobal(self.handle.as_ptr(), key_ptr) != 0 }
+        unsafe { BNDatabaseHasGlobal(self.handle.as_ptr(), key_raw.as_ptr()) != 0 }
     }
 
     /// Get a list of keys for all globals in the database
@@ -158,33 +157,28 @@ impl Database {
     /// Get a specific global by key
     pub fn read_global<S: AsCStr>(&self, key: S) -> Option<BnString> {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
-        let result = unsafe { BNReadDatabaseGlobal(self.handle.as_ptr(), key_ptr) };
+        let result = unsafe { BNReadDatabaseGlobal(self.handle.as_ptr(), key_raw.as_ptr()) };
         unsafe { NonNull::new(result).map(|_| BnString::from_raw(result)) }
     }
 
     /// Write a global into the database
     pub fn write_global<K: AsCStr, V: AsCStr>(&self, key: K, value: V) -> bool {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
         let value_raw = value.to_cstr();
-        let value_ptr = value_raw.as_ref().as_ptr() as *const c_char;
-        unsafe { BNWriteDatabaseGlobal(self.handle.as_ptr(), key_ptr, value_ptr) }
+        unsafe { BNWriteDatabaseGlobal(self.handle.as_ptr(), key_raw.as_ptr(), value_raw.as_ptr()) }
     }
 
     /// Get a specific global by key, as a binary buffer
     pub fn read_global_data<S: AsCStr>(&self, key: S) -> Option<DataBuffer> {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
-        let result = unsafe { BNReadDatabaseGlobalData(self.handle.as_ptr(), key_ptr) };
+        let result = unsafe { BNReadDatabaseGlobalData(self.handle.as_ptr(), key_raw.as_ptr()) };
         NonNull::new(result).map(|_| DataBuffer::from_raw(result))
     }
 
     /// Write a binary buffer into a global in the database
     pub fn write_global_data<K: AsCStr>(&self, key: K, value: &DataBuffer) -> bool {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
-        unsafe { BNWriteDatabaseGlobalData(self.handle.as_ptr(), key_ptr, value.as_raw()) }
+        unsafe { BNWriteDatabaseGlobalData(self.handle.as_ptr(), key_raw.as_ptr(), value.as_raw()) }
     }
 
     /// Get the owning FileMetadata
diff --git a/rust/src/database/kvs.rs b/rust/src/database/kvs.rs
index 43cf17eb..e84da7f3 100644
--- a/rust/src/database/kvs.rs
+++ b/rust/src/database/kvs.rs
@@ -9,7 +9,6 @@ use binaryninjacore_sys::{
     BNNewKeyValueStoreReference, BNSetKeyValueStoreBuffer,
 };
 use std::collections::HashMap;
-use std::ffi::c_char;
 use std::fmt::Debug;
 use std::ptr::NonNull;
 
@@ -44,7 +43,7 @@ impl KeyValueStore {
     /// Get the value for a single key
     pub fn value<S: AsCStr>(&self, key: S) -> Option<DataBuffer> {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
+        let key_ptr = key_raw.as_ptr();
         let result = unsafe { BNGetKeyValueStoreBuffer(self.handle.as_ptr(), key_ptr) };
         NonNull::new(result).map(|_| DataBuffer::from_raw(result))
     }
@@ -52,7 +51,7 @@ impl KeyValueStore {
     /// Set the value for a single key
     pub fn set_value<S: AsCStr>(&self, key: S, value: &DataBuffer) -> bool {
         let key_raw = key.to_cstr();
-        let key_ptr = key_raw.as_ref().as_ptr() as *const c_char;
+        let key_ptr = key_raw.as_ptr();
         unsafe { BNSetKeyValueStoreBuffer(self.handle.as_ptr(), key_ptr, value.as_raw()) }
     }
 
@@ -66,7 +65,7 @@ impl KeyValueStore {
     /// Begin storing new keys into a namespace
     pub fn begin_namespace<S: AsCStr>(&self, name: S) {
         let name_raw = name.to_cstr();
-        let name_ptr = name_raw.as_ref().as_ptr() as *const c_char;
+        let name_ptr = name_raw.as_ptr();
         unsafe { BNBeginKeyValueStoreNamespace(self.handle.as_ptr(), name_ptr) }
     }
 
diff --git a/rust/src/database/snapshot.rs b/rust/src/database/snapshot.rs
index 7d7e39d1..599a749a 100644
--- a/rust/src/database/snapshot.rs
+++ b/rust/src/database/snapshot.rs
@@ -14,7 +14,7 @@ use binaryninjacore_sys::{
     BNReadSnapshotDataWithProgress, BNSetSnapshotName, BNSnapshot, BNSnapshotHasAncestor,
     BNSnapshotHasContents, BNSnapshotHasUndo, BNSnapshotStoreData,
 };
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ptr::NonNull;
@@ -52,7 +52,7 @@ impl Snapshot {
     /// Set the displayed snapshot name
     pub fn set_name<S: AsCStr>(&self, value: S) {
         let value_raw = value.to_cstr();
-        let value_ptr = value_raw.as_ref().as_ptr() as *const c_char;
+        let value_ptr = value_raw.as_ptr();
         unsafe { BNSetSnapshotName(self.handle.as_ptr(), value_ptr) }
     }
 
diff --git a/rust/src/debuginfo.rs b/rust/src/debuginfo.rs
index 0afe4c77..9336a28d 100644
--- a/rust/src/debuginfo.rs
+++ b/rust/src/debuginfo.rs
@@ -117,7 +117,7 @@ impl DebugInfoParser {
     /// Returns debug info parser of the given name, if it exists
     pub fn from_name<S: AsCStr>(name: S) -> Result<Ref<Self>, ()> {
         let name = name.to_cstr();
-        let parser = unsafe { BNGetDebugInfoParserByName(name.as_ref().as_ptr() as *mut _) };
+        let parser = unsafe { BNGetDebugInfoParserByName(name.as_ptr()) };
 
         if parser.is_null() {
             Err(())
@@ -260,7 +260,7 @@ impl DebugInfoParser {
         }
 
         let name = name.to_cstr();
-        let name_ptr = name.as_ref().as_ptr() as *mut _;
+        let name_ptr = name.as_ptr();
         let ctxt = Box::into_raw(Box::new(parser_callbacks));
 
         unsafe {
@@ -421,13 +421,8 @@ impl DebugInfo {
         let parser_name = parser_name.to_cstr();
 
         let mut count: usize = 0;
-        let debug_types_ptr = unsafe {
-            BNGetDebugTypes(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                &mut count,
-            )
-        };
+        let debug_types_ptr =
+            unsafe { BNGetDebugTypes(self.handle, parser_name.as_ptr(), &mut count) };
         let result: Vec<_> = unsafe {
             std::slice::from_raw_parts_mut(debug_types_ptr, count)
                 .iter()
@@ -459,13 +454,8 @@ impl DebugInfo {
         let parser_name = parser_name.to_cstr();
 
         let mut count: usize = 0;
-        let functions_ptr = unsafe {
-            BNGetDebugFunctions(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                &mut count,
-            )
-        };
+        let functions_ptr =
+            unsafe { BNGetDebugFunctions(self.handle, parser_name.as_ptr(), &mut count) };
 
         let result: Vec<DebugFunctionInfo> = unsafe {
             std::slice::from_raw_parts_mut(functions_ptr, count)
@@ -502,13 +492,8 @@ impl DebugInfo {
         let parser_name = parser_name.to_cstr();
 
         let mut count: usize = 0;
-        let data_variables_ptr = unsafe {
-            BNGetDebugDataVariables(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                &mut count,
-            )
-        };
+        let data_variables_ptr =
+            unsafe { BNGetDebugDataVariables(self.handle, parser_name.as_ptr(), &mut count) };
 
         let result: Vec<NamedDataVariableWithType> = unsafe {
             std::slice::from_raw_parts_mut(data_variables_ptr, count)
@@ -541,13 +526,8 @@ impl DebugInfo {
         let parser_name = parser_name.to_cstr();
         let name = name.to_cstr();
 
-        let result = unsafe {
-            BNGetDebugTypeByName(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                name.as_ref().as_ptr() as *mut _,
-            )
-        };
+        let result =
+            unsafe { BNGetDebugTypeByName(self.handle, parser_name.as_ptr(), name.as_ptr()) };
         if !result.is_null() {
             Some(unsafe { Type::ref_from_raw(result) })
         } else {
@@ -566,8 +546,8 @@ impl DebugInfo {
         unsafe {
             if BNGetDebugDataVariableByName(
                 self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                name.as_ref().as_ptr() as *mut _,
+                parser_name.as_ptr(),
+                name.as_ptr(),
                 &mut dv,
             ) {
                 Some(NamedDataVariableWithType::from_owned_raw(dv))
@@ -585,12 +565,8 @@ impl DebugInfo {
         let parser_name = parser_name.to_cstr();
         let mut dv = BNDataVariableAndName::default();
         unsafe {
-            if BNGetDebugDataVariableByAddress(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                address,
-                &mut dv,
-            ) {
+            if BNGetDebugDataVariableByAddress(self.handle, parser_name.as_ptr(), address, &mut dv)
+            {
                 Some(NamedDataVariableWithType::from_owned_raw(dv))
             } else {
                 None
@@ -602,9 +578,8 @@ impl DebugInfo {
     pub fn get_types_by_name<S: AsCStr>(&self, name: S) -> Vec<NameAndType> {
         let mut count: usize = 0;
         let name = name.to_cstr();
-        let raw_names_and_types_ptr = unsafe {
-            BNGetDebugTypesByName(self.handle, name.as_ref().as_ptr() as *mut _, &mut count)
-        };
+        let raw_names_and_types_ptr =
+            unsafe { BNGetDebugTypesByName(self.handle, name.as_ptr(), &mut count) };
 
         let raw_names_and_types: &[BNNameAndType] =
             unsafe { std::slice::from_raw_parts(raw_names_and_types_ptr, count) };
@@ -623,9 +598,8 @@ impl DebugInfo {
         let name = name.to_cstr();
 
         let mut count: usize = 0;
-        let raw_variables_and_names = unsafe {
-            BNGetDebugDataVariablesByName(self.handle, name.as_ref().as_ptr() as *mut _, &mut count)
-        };
+        let raw_variables_and_names =
+            unsafe { BNGetDebugDataVariablesByName(self.handle, name.as_ptr(), &mut count) };
 
         let variables_and_names: &[*mut BNDataVariableAndName] =
             unsafe { std::slice::from_raw_parts(raw_variables_and_names as *mut _, count) };
@@ -674,66 +648,44 @@ impl DebugInfo {
     pub fn remove_parser_info<S: AsCStr>(&self, parser_name: S) -> bool {
         let parser_name = parser_name.to_cstr();
 
-        unsafe { BNRemoveDebugParserInfo(self.handle, parser_name.as_ref().as_ptr() as *mut _) }
+        unsafe { BNRemoveDebugParserInfo(self.handle, parser_name.as_ptr()) }
     }
 
     pub fn remove_parser_types<S: AsCStr>(&self, parser_name: S) -> bool {
         let parser_name = parser_name.to_cstr();
 
-        unsafe { BNRemoveDebugParserTypes(self.handle, parser_name.as_ref().as_ptr() as *mut _) }
+        unsafe { BNRemoveDebugParserTypes(self.handle, parser_name.as_ptr()) }
     }
 
     pub fn remove_parser_functions<S: AsCStr>(&self, parser_name: S) -> bool {
         let parser_name = parser_name.to_cstr();
 
-        unsafe {
-            BNRemoveDebugParserFunctions(self.handle, parser_name.as_ref().as_ptr() as *mut _)
-        }
+        unsafe { BNRemoveDebugParserFunctions(self.handle, parser_name.as_ptr()) }
     }
 
     pub fn remove_parser_data_variables<S: AsCStr>(&self, parser_name: S) -> bool {
         let parser_name = parser_name.to_cstr();
 
-        unsafe {
-            BNRemoveDebugParserDataVariables(self.handle, parser_name.as_ref().as_ptr() as *mut _)
-        }
+        unsafe { BNRemoveDebugParserDataVariables(self.handle, parser_name.as_ptr()) }
     }
 
     pub fn remove_type_by_name<S: AsCStr>(&self, parser_name: S, name: S) -> bool {
         let parser_name = parser_name.to_cstr();
         let name = name.to_cstr();
 
-        unsafe {
-            BNRemoveDebugTypeByName(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                name.as_ref().as_ptr() as *mut _,
-            )
-        }
+        unsafe { BNRemoveDebugTypeByName(self.handle, parser_name.as_ptr(), name.as_ptr()) }
     }
 
     pub fn remove_function_by_index<S: AsCStr>(&self, parser_name: S, index: usize) -> bool {
         let parser_name = parser_name.to_cstr();
 
-        unsafe {
-            BNRemoveDebugFunctionByIndex(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                index,
-            )
-        }
+        unsafe { BNRemoveDebugFunctionByIndex(self.handle, parser_name.as_ptr(), index) }
     }
 
     pub fn remove_data_variable_by_address<S: AsCStr>(&self, parser_name: S, address: u64) -> bool {
         let parser_name = parser_name.to_cstr();
 
-        unsafe {
-            BNRemoveDebugDataVariableByAddress(
-                self.handle,
-                parser_name.as_ref().as_ptr() as *mut _,
-                address,
-            )
-        }
+        unsafe { BNRemoveDebugDataVariableByAddress(self.handle, parser_name.as_ptr(), address) }
     }
 
     /// Adds a type scoped under the current parser's name to the debug info
@@ -745,7 +697,7 @@ impl DebugInfo {
         unsafe {
             BNAddDebugType(
                 self.handle,
-                name.as_ref().as_ptr() as *mut _,
+                name.as_ptr(),
                 new_type.handle,
                 raw_components.as_ptr() as *mut _,
                 components.len(),
@@ -776,7 +728,8 @@ impl DebugInfo {
 
         unsafe {
             for component in &new_func.components {
-                components_array.push(BNAllocString(component.clone().to_cstr().as_ptr() as _));
+                let component = component.to_cstr();
+                components_array.push(BNAllocString(component.as_ptr()));
             }
 
             for local_variable in &new_func.local_variables {
@@ -839,7 +792,7 @@ impl DebugInfo {
                         self.handle,
                         address,
                         t.handle,
-                        name.as_ref().as_ptr() as *mut _,
+                        name.as_ptr(),
                         components.as_ptr() as _,
                         components.len(),
                     )
diff --git a/rust/src/demangle.rs b/rust/src/demangle.rs
index 9cec0c93..a883dc82 100644
--- a/rust/src/demangle.rs
+++ b/rust/src/demangle.rs
@@ -32,14 +32,13 @@ pub fn demangle_generic<S: AsCStr>(
     view: Option<&BinaryView>,
     simplify: bool,
 ) -> Option<(QualifiedName, Option<Ref<Type>>)> {
-    let mangled_name_bwn = mangled_name.to_cstr();
-    let mangled_name_ptr = mangled_name_bwn.as_ref();
+    let mangled_name = mangled_name.to_cstr();
     let mut out_type: *mut BNType = std::ptr::null_mut();
     let mut out_name = BNQualifiedName::default();
     let res = unsafe {
         BNDemangleGeneric(
             arch.handle,
-            mangled_name_ptr.as_ptr() as *const c_char,
+            mangled_name.as_ptr(),
             &mut out_type,
             &mut out_name,
             view.map(|v| v.handle).unwrap_or(std::ptr::null_mut()),
@@ -59,13 +58,12 @@ pub fn demangle_generic<S: AsCStr>(
 }
 
 pub fn demangle_llvm<S: AsCStr>(mangled_name: S, simplify: bool) -> Option<QualifiedName> {
-    let mangled_name_bwn = mangled_name.to_cstr();
-    let mangled_name_ptr = mangled_name_bwn.as_ref();
+    let mangled_name = mangled_name.to_cstr();
     let mut out_name: *mut *mut std::os::raw::c_char = std::ptr::null_mut();
     let mut out_size: usize = 0;
     let res = unsafe {
         BNDemangleLLVM(
-            mangled_name_ptr.as_ptr() as *const c_char,
+            mangled_name.as_ptr(),
             &mut out_name,
             &mut out_size,
             simplify,
@@ -92,15 +90,14 @@ pub fn demangle_gnu3<S: AsCStr>(
     mangled_name: S,
     simplify: bool,
 ) -> Option<(QualifiedName, Option<Ref<Type>>)> {
-    let mangled_name_bwn = mangled_name.to_cstr();
-    let mangled_name_ptr = mangled_name_bwn.as_ref();
+    let mangled_name = mangled_name.to_cstr();
     let mut out_type: *mut BNType = std::ptr::null_mut();
     let mut out_name: *mut *mut std::os::raw::c_char = std::ptr::null_mut();
     let mut out_size: usize = 0;
     let res = unsafe {
         BNDemangleGNU3(
             arch.handle,
-            mangled_name_ptr.as_ptr() as *const c_char,
+            mangled_name.as_ptr(),
             &mut out_type,
             &mut out_name,
             &mut out_size,
@@ -133,16 +130,14 @@ pub fn demangle_ms<S: AsCStr>(
     mangled_name: S,
     simplify: bool,
 ) -> Option<(QualifiedName, Option<Ref<Type>>)> {
-    let mangled_name_bwn = mangled_name.to_cstr();
-    let mangled_name_ptr = mangled_name_bwn.as_ref();
-
+    let mangled_name = mangled_name.to_cstr();
     let mut out_type: *mut BNType = std::ptr::null_mut();
     let mut out_name: *mut *mut std::os::raw::c_char = std::ptr::null_mut();
     let mut out_size: usize = 0;
     let res = unsafe {
         BNDemangleMS(
             arch.handle,
-            mangled_name_ptr.as_ptr() as *const c_char,
+            mangled_name.as_ptr(),
             &mut out_type,
             &mut out_name,
             &mut out_size,
@@ -309,7 +304,7 @@ impl Demangler {
         }
 
         let name = name.to_cstr();
-        let name_ptr = name.as_ref().as_ptr() as *mut _;
+        let name_ptr = name.as_ptr();
         let ctxt = Box::into_raw(Box::new(demangler));
 
         let callbacks = BNDemanglerCallbacks {
diff --git a/rust/src/download_provider.rs b/rust/src/download_provider.rs
index f9e21e64..7d28058f 100644
--- a/rust/src/download_provider.rs
+++ b/rust/src/download_provider.rs
@@ -14,9 +14,8 @@ pub struct DownloadProvider {
 
 impl DownloadProvider {
     pub fn get<S: AsCStr>(name: S) -> Option<DownloadProvider> {
-        let result = unsafe {
-            BNGetDownloadProviderByName(name.to_cstr().as_ref().as_ptr() as *const c_char)
-        };
+        let name = name.to_cstr();
+        let result = unsafe { BNGetDownloadProviderByName(name.as_ptr()) };
         if result.is_null() {
             return None;
         }
@@ -145,10 +144,11 @@ impl DownloadInstance {
             progressContext: callbacks as *mut c_void,
         };
 
+        let url_raw = url.to_cstr();
         let result = unsafe {
             BNPerformDownloadRequest(
                 self.handle,
-                url.to_cstr().as_ref().as_ptr() as *const c_char,
+                url_raw.as_ptr(),
                 &mut cbs as *mut BNDownloadInstanceOutputCallbacks,
             )
         };
@@ -225,8 +225,8 @@ impl DownloadInstance {
         let mut header_value_ptrs = vec![];
 
         for (key, value) in header_keys.iter().zip(header_values.iter()) {
-            header_key_ptrs.push(key.as_ref().as_ptr() as *const c_char);
-            header_value_ptrs.push(value.as_ref().as_ptr() as *const c_char);
+            header_key_ptrs.push(key.as_ptr());
+            header_value_ptrs.push(value.as_ptr());
         }
 
         let callbacks = Box::into_raw(Box::new(callbacks));
@@ -241,11 +241,13 @@ impl DownloadInstance {
 
         let mut response: *mut BNDownloadInstanceResponse = null_mut();
 
+        let method_raw = method.to_cstr();
+        let url_raw = url.to_cstr();
         let result = unsafe {
             BNPerformCustomRequest(
                 self.handle,
-                method.to_cstr().as_ref().as_ptr() as *const c_char,
-                url.to_cstr().as_ref().as_ptr() as *const c_char,
+                method_raw.as_ptr(),
+                url_raw.as_ptr(),
                 header_key_ptrs.len() as u64,
                 header_key_ptrs.as_ptr(),
                 header_value_ptrs.as_ptr(),
diff --git a/rust/src/external_library.rs b/rust/src/external_library.rs
index 26425ccd..57848a7a 100644
--- a/rust/src/external_library.rs
+++ b/rust/src/external_library.rs
@@ -3,7 +3,6 @@ use crate::rc::{CoreArrayProvider, CoreArrayProviderInner, Guard, Ref, RefCounta
 use crate::string::{AsCStr, BnString};
 use crate::symbol::Symbol;
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::fmt::Debug;
 use std::ptr::NonNull;
 
@@ -168,10 +167,15 @@ impl ExternalLocation {
     /// Set the symbol pointed to by this ExternalLocation.
     /// ExternalLocations must have a valid target address and/or symbol set.
     pub fn set_target_symbol<S: AsCStr>(&self, symbol: Option<S>) -> bool {
-        let symbol = symbol
-            .map(|x| x.to_cstr().as_ref().as_ptr() as *const c_char)
-            .unwrap_or(std::ptr::null_mut());
-        unsafe { BNExternalLocationSetTargetSymbol(self.handle.as_ptr(), symbol) }
+        match symbol {
+            Some(sym) => {
+                let raw_sym = sym.to_cstr();
+                unsafe { BNExternalLocationSetTargetSymbol(self.handle.as_ptr(), raw_sym.as_ptr()) }
+            }
+            None => unsafe {
+                BNExternalLocationSetTargetSymbol(self.handle.as_ptr(), std::ptr::null())
+            },
+        }
     }
 }
 
diff --git a/rust/src/file_metadata.rs b/rust/src/file_metadata.rs
index 6b6a79a8..100f255b 100644
--- a/rust/src/file_metadata.rs
+++ b/rust/src/file_metadata.rs
@@ -79,7 +79,7 @@ impl FileMetadata {
         let name = name.to_cstr();
 
         unsafe {
-            BNSetFilename(self.handle, name.as_ref().as_ptr() as *mut _);
+            BNSetFilename(self.handle, name.as_ptr());
         }
     }
 
@@ -275,7 +275,7 @@ impl FileMetadata {
 
     pub fn open_database<S: AsCStr>(&self, filename: S) -> Result<Ref<BinaryView>, ()> {
         let filename = filename.to_cstr();
-        let filename_ptr = filename.as_ref().as_ptr() as *mut _;
+        let filename_ptr = filename.as_ptr();
 
         let view = unsafe { BNOpenExistingDatabase(self.handle, filename_ptr) };
 
@@ -292,7 +292,7 @@ impl FileMetadata {
         mut progress: P,
     ) -> Result<Ref<BinaryView>, ()> {
         let filename = filename.to_cstr();
-        let filename_ptr = filename.as_ref().as_ptr() as *mut _;
+        let filename_ptr = filename.as_ptr();
 
         let view = unsafe {
             BNOpenExistingDatabaseWithProgress(
diff --git a/rust/src/function.rs b/rust/src/function.rs
index dcefaa35..36bd1d56 100644
--- a/rust/src/function.rs
+++ b/rust/src/function.rs
@@ -376,7 +376,7 @@ impl Function {
         let raw = comment.to_cstr();
 
         unsafe {
-            BNSetFunctionComment(self.handle, raw.as_ref().as_ptr() as *mut _);
+            BNSetFunctionComment(self.handle, raw.as_ptr());
         }
     }
 
@@ -398,7 +398,7 @@ impl Function {
         let raw = comment.to_cstr();
 
         unsafe {
-            BNSetCommentForAddress(self.handle, addr, raw.as_ref().as_ptr() as *mut _);
+            BNSetCommentForAddress(self.handle, addr, raw.as_ptr());
         }
     }
 
@@ -1712,7 +1712,7 @@ impl Function {
         let arch = arch.unwrap_or_else(|| self.arch());
         let enum_display_typeid = enum_display_typeid.map(AsCStr::to_cstr);
         let enum_display_typeid_ptr = enum_display_typeid
-            .map(|x| x.as_ref().as_ptr() as *const c_char)
+            .map(|x| x.as_ptr())
             .unwrap_or(std::ptr::null());
         unsafe {
             BNSetIntegerConstantDisplayType(
diff --git a/rust/src/interaction.rs b/rust/src/interaction.rs
index 7e007eb9..9994608f 100644
--- a/rust/src/interaction.rs
+++ b/rust/src/interaction.rs
@@ -23,16 +23,16 @@ use crate::binary_view::BinaryView;
 use crate::rc::Ref;
 use crate::string::{AsCStr, BnString};
 
+pub type MessageBoxButtonSet = BNMessageBoxButtonSet;
+pub type MessageBoxIcon = BNMessageBoxIcon;
+pub type MessageBoxButtonResult = BNMessageBoxButtonResult;
+
 pub fn get_text_line_input(prompt: &str, title: &str) -> Option<String> {
     let mut value: *mut c_char = std::ptr::null_mut();
 
-    let result = unsafe {
-        BNGetTextLineInput(
-            &mut value,
-            prompt.to_cstr().as_ptr() as *mut _,
-            title.to_cstr().as_ptr() as *mut _,
-        )
-    };
+    let prompt = prompt.to_cstr();
+    let title = title.to_cstr();
+    let result = unsafe { BNGetTextLineInput(&mut value, prompt.as_ptr(), title.as_ptr()) };
     if !result {
         return None;
     }
@@ -43,13 +43,9 @@ pub fn get_text_line_input(prompt: &str, title: &str) -> Option<String> {
 pub fn get_integer_input(prompt: &str, title: &str) -> Option<i64> {
     let mut value: i64 = 0;
 
-    let result = unsafe {
-        BNGetIntegerInput(
-            &mut value,
-            prompt.to_cstr().as_ptr() as *mut _,
-            title.to_cstr().as_ptr() as *mut _,
-        )
-    };
+    let prompt = prompt.to_cstr();
+    let title = title.to_cstr();
+    let result = unsafe { BNGetIntegerInput(&mut value, prompt.as_ptr(), title.as_ptr()) };
 
     if !result {
         return None;
@@ -61,11 +57,13 @@ pub fn get_integer_input(prompt: &str, title: &str) -> Option<i64> {
 pub fn get_address_input(prompt: &str, title: &str) -> Option<u64> {
     let mut value: u64 = 0;
 
+    let prompt = prompt.to_cstr();
+    let title = title.to_cstr();
     let result = unsafe {
         BNGetAddressInput(
             &mut value,
-            prompt.to_cstr().as_ptr() as *mut _,
-            title.to_cstr().as_ptr() as *mut _,
+            prompt.as_ptr(),
+            title.as_ptr(),
             std::ptr::null_mut(),
             0,
         )
@@ -81,13 +79,9 @@ pub fn get_address_input(prompt: &str, title: &str) -> Option<u64> {
 pub fn get_open_filename_input(prompt: &str, extension: &str) -> Option<PathBuf> {
     let mut value: *mut c_char = std::ptr::null_mut();
 
-    let result = unsafe {
-        BNGetOpenFileNameInput(
-            &mut value,
-            prompt.to_cstr().as_ptr() as *mut _,
-            extension.to_cstr().as_ptr() as *mut _,
-        )
-    };
+    let prompt = prompt.to_cstr();
+    let extension = extension.to_cstr();
+    let result = unsafe { BNGetOpenFileNameInput(&mut value, prompt.as_ptr(), extension.as_ptr()) };
     if !result {
         return None;
     }
@@ -103,12 +97,15 @@ pub fn get_save_filename_input(
 ) -> Option<PathBuf> {
     let mut value: *mut c_char = std::ptr::null_mut();
 
+    let prompt = prompt.to_cstr();
+    let extension = extension.to_cstr();
+    let default_name = default_name.to_cstr();
     let result = unsafe {
         BNGetSaveFileNameInput(
             &mut value,
-            prompt.to_cstr().as_ptr() as *mut _,
-            extension.to_cstr().as_ptr() as *mut _,
-            default_name.to_cstr().as_ptr() as *mut _,
+            prompt.as_ptr(),
+            extension.as_ptr(),
+            default_name.as_ptr(),
         )
     };
     if !result {
@@ -122,13 +119,10 @@ pub fn get_save_filename_input(
 pub fn get_directory_name_input(prompt: &str, default_name: &str) -> Option<PathBuf> {
     let mut value: *mut c_char = std::ptr::null_mut();
 
-    let result = unsafe {
-        BNGetDirectoryNameInput(
-            &mut value,
-            prompt.to_cstr().as_ptr() as *mut _,
-            default_name.to_cstr().as_ptr() as *mut _,
-        )
-    };
+    let prompt = prompt.to_cstr();
+    let default_name = default_name.to_cstr();
+    let result =
+        unsafe { BNGetDirectoryNameInput(&mut value, prompt.as_ptr(), default_name.as_ptr()) };
     if !result {
         return None;
     }
@@ -137,23 +131,15 @@ pub fn get_directory_name_input(prompt: &str, default_name: &str) -> Option<Path
     Some(PathBuf::from(path))
 }
 
-pub type MessageBoxButtonSet = BNMessageBoxButtonSet;
-pub type MessageBoxIcon = BNMessageBoxIcon;
-pub type MessageBoxButtonResult = BNMessageBoxButtonResult;
 pub fn show_message_box(
     title: &str,
     text: &str,
     buttons: MessageBoxButtonSet,
     icon: MessageBoxIcon,
 ) -> MessageBoxButtonResult {
-    unsafe {
-        BNShowMessageBox(
-            title.to_cstr().as_ptr() as *mut _,
-            text.to_cstr().as_ptr() as *mut _,
-            buttons,
-            icon,
-        )
-    }
+    let title = title.to_cstr();
+    let text = text.to_cstr();
+    unsafe { BNShowMessageBox(title.as_ptr(), text.as_ptr(), buttons, icon) }
 }
 
 pub enum FormResponses {
@@ -210,7 +196,7 @@ impl FormInputBuilder {
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::LabelFormField;
         result.hasDefault = false;
-        result.prompt = text.as_ref().as_ptr() as *const c_char;
+        result.prompt = text.as_ptr();
         self.fields.push(result);
 
         self.data.push(FormData::Label { _text: text });
@@ -233,10 +219,10 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::TextLineFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
         result.hasDefault = default.is_some();
         if let Some(ref default) = default {
-            result.stringDefault = default.as_ref().as_ptr() as *const c_char;
+            result.stringDefault = default.as_ptr();
         }
         self.fields.push(result);
 
@@ -254,10 +240,10 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::MultilineTextFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
         result.hasDefault = default.is_some();
         if let Some(ref default) = default {
-            result.stringDefault = default.as_ref().as_ptr() as *const c_char;
+            result.stringDefault = default.as_ptr();
         }
         self.fields.push(result);
 
@@ -274,7 +260,7 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::IntegerFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
         result.hasDefault = default.is_some();
         if let Some(default) = default {
             result.intDefault = default;
@@ -297,7 +283,7 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::AddressFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
         if let Some(view) = view {
             // the view is being moved into result, there is no need to clone
             // and drop is intentionally being avoided with `Ref::into_raw`
@@ -321,11 +307,8 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::ChoiceFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
-        let mut raw_choices: Vec<*const c_char> = choices
-            .iter()
-            .map(|c| c.as_ref().as_ptr() as *const c_char)
-            .collect();
+        result.prompt = prompt.as_ptr();
+        let mut raw_choices: Vec<*const c_char> = choices.iter().map(|c| c.as_ptr()).collect();
         result.choices = raw_choices.as_mut_ptr();
         result.count = choices.len();
         result.hasDefault = default.is_some();
@@ -359,11 +342,11 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::OpenFileNameFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
-        result.ext = ext.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
+        result.ext = ext.as_ptr();
         result.hasDefault = default.is_some();
         if let Some(ref default) = default {
-            result.stringDefault = default.as_ref().as_ptr() as *const c_char;
+            result.stringDefault = default.as_ptr();
         }
         self.fields.push(result);
 
@@ -398,12 +381,12 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::SaveFileNameFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
-        result.ext = ext.as_ref().as_ptr() as *const c_char;
-        result.defaultName = default_name.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
+        result.ext = ext.as_ptr();
+        result.defaultName = default_name.as_ptr();
         result.hasDefault = default.is_some();
         if let Some(ref default) = default {
-            result.stringDefault = default.as_ref().as_ptr() as *const c_char;
+            result.stringDefault = default.as_ptr();
         }
         self.fields.push(result);
 
@@ -433,11 +416,11 @@ impl FormInputBuilder {
 
         let mut result = unsafe { std::mem::zeroed::<BNFormInputField>() };
         result.type_ = BNFormInputFieldType::DirectoryNameFormField;
-        result.prompt = prompt.as_ref().as_ptr() as *const c_char;
-        result.defaultName = default_name.as_ref().as_ptr() as *const c_char;
+        result.prompt = prompt.as_ptr();
+        result.defaultName = default_name.as_ptr();
         result.hasDefault = default.is_some();
         if let Some(ref default) = default {
-            result.stringDefault = default.as_ref().as_ptr() as *const c_char;
+            result.stringDefault = default.as_ptr();
         }
         self.fields.push(result);
 
@@ -491,13 +474,8 @@ impl FormInputBuilder {
     /// println!("{} {} likes {}", &first_name, &last_name, food);
     /// ```
     pub fn get_form_input(&mut self, title: &str) -> Vec<FormResponses> {
-        if unsafe {
-            BNGetFormInput(
-                self.fields.as_mut_ptr(),
-                self.fields.len(),
-                title.to_cstr().as_ptr() as *const _,
-            )
-        } {
+        let title = title.to_cstr();
+        if unsafe { BNGetFormInput(self.fields.as_mut_ptr(), self.fields.len(), title.as_ptr()) } {
             let result = self
                 .fields
                 .iter()
@@ -575,9 +553,10 @@ pub fn run_progress_dialog<F: Fn(Box<dyn Fn(usize, usize) -> Result<(), ()>>)>(
         })
     }
 
+    let title = title.to_cstr();
     if unsafe {
         BNRunProgressDialog(
-            title.to_cstr().as_ptr() as *mut _,
+            title.as_ptr(),
             can_cancel,
             Some(cb_task::<F>),
             &mut ctxt as *mut _ as *mut c_void,
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 63872be3..c0b3a38c 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -285,7 +285,7 @@ pub fn bundled_plugin_directory() -> Result<PathBuf, ()> {
 
 pub fn set_bundled_plugin_directory(new_dir: impl AsRef<Path>) {
     let new_dir = new_dir.as_ref().to_cstr();
-    unsafe { BNSetBundledPluginDirectory(new_dir.as_ptr() as *const c_char) };
+    unsafe { BNSetBundledPluginDirectory(new_dir.as_ptr()) };
 }
 
 pub fn user_directory() -> PathBuf {
@@ -330,7 +330,7 @@ pub fn save_last_run() {
 pub fn path_relative_to_bundled_plugin_directory(path: impl AsRef<Path>) -> Result<PathBuf, ()> {
     let path_raw = path.as_ref().to_cstr();
     let s: *mut c_char =
-        unsafe { BNGetPathRelativeToBundledPluginDirectory(path_raw.as_ptr() as *const c_char) };
+        unsafe { BNGetPathRelativeToBundledPluginDirectory(path_raw.as_ptr()) };
     if s.is_null() {
         return Err(());
     }
@@ -340,7 +340,7 @@ pub fn path_relative_to_bundled_plugin_directory(path: impl AsRef<Path>) -> Resu
 pub fn path_relative_to_user_plugin_directory(path: impl AsRef<Path>) -> Result<PathBuf, ()> {
     let path_raw = path.as_ref().to_cstr();
     let s: *mut c_char =
-        unsafe { BNGetPathRelativeToUserPluginDirectory(path_raw.as_ptr() as *const c_char) };
+        unsafe { BNGetPathRelativeToUserPluginDirectory(path_raw.as_ptr()) };
     if s.is_null() {
         return Err(());
     }
@@ -350,7 +350,7 @@ pub fn path_relative_to_user_plugin_directory(path: impl AsRef<Path>) -> Result<
 pub fn path_relative_to_user_directory(path: impl AsRef<Path>) -> Result<PathBuf, ()> {
     let path_raw = path.as_ref().to_cstr();
     let s: *mut c_char =
-        unsafe { BNGetPathRelativeToUserDirectory(path_raw.as_ptr() as *const c_char) };
+        unsafe { BNGetPathRelativeToUserDirectory(path_raw.as_ptr()) };
     if s.is_null() {
         return Err(());
     }
@@ -475,7 +475,7 @@ impl VersionInfo {
 
     pub fn from_string<S: AsCStr>(string: S) -> Self {
         let string = string.to_cstr();
-        let result = unsafe { BNParseVersionString(string.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNParseVersionString(string.as_ptr()) };
         Self::from_owned_raw(result)
     }
 }
@@ -534,8 +534,7 @@ pub fn license_count() -> i32 {
 #[cfg(not(feature = "demo"))]
 pub fn set_license<S: AsCStr + Default>(license: Option<S>) {
     let license = license.unwrap_or_default().to_cstr();
-    let license_slice = license.as_ref();
-    unsafe { BNSetLicense(license_slice.as_ptr() as *const c_char) }
+    unsafe { BNSetLicense(license.as_ptr()) }
 }
 
 #[cfg(feature = "demo")]
@@ -560,8 +559,7 @@ pub fn is_ui_enabled() -> bool {
 
 pub fn is_database<S: AsCStr>(filename: S) -> bool {
     let filename = filename.to_cstr();
-    let filename_slice = filename.as_ref();
-    unsafe { BNIsDatabase(filename_slice.as_ptr() as *const c_char) }
+    unsafe { BNIsDatabase(filename.as_ptr()) }
 }
 
 pub fn plugin_abi_version() -> u32 {
@@ -589,11 +587,13 @@ pub fn plugin_ui_abi_minimum_version() -> u32 {
 }
 
 pub fn add_required_plugin_dependency<S: AsCStr>(name: S) {
-    unsafe { BNAddRequiredPluginDependency(name.to_cstr().as_ref().as_ptr() as *const c_char) };
+    let raw_name = name.to_cstr();
+    unsafe { BNAddRequiredPluginDependency(raw_name.as_ptr()) };
 }
 
 pub fn add_optional_plugin_dependency<S: AsCStr>(name: S) {
-    unsafe { BNAddOptionalPluginDependency(name.to_cstr().as_ref().as_ptr() as *const c_char) };
+    let raw_name = name.to_cstr();
+    unsafe { BNAddOptionalPluginDependency(raw_name.as_ptr()) };
 }
 
 // Provide ABI version automatically so that the core can verify binary compatibility
diff --git a/rust/src/logger.rs b/rust/src/logger.rs
index c06f4dfc..5f14af69 100644
--- a/rust/src/logger.rs
+++ b/rust/src/logger.rs
@@ -35,7 +35,7 @@ use binaryninjacore_sys::{
 };
 
 use crate::rc::{Ref, RefCountable};
-use crate::string::BnString;
+use crate::string::{AsCStr, BnString};
 use log;
 use log::LevelFilter;
 use std::ffi::{CStr, CString};
@@ -139,12 +139,12 @@ impl log::Log for Ref<Logger> {
 
         if let Ok(msg) = CString::new(format!("{}", record.args())) {
             let percent_s = CString::new("%s").expect("'%s' has no null bytes");
-            let logger_name = self.name();
+            let logger_name = self.name().to_cstr();
             unsafe {
                 BNLog(
                     self.session_id(),
                     level,
-                    logger_name.as_ptr() as *const c_char,
+                    logger_name.as_ptr(),
                     0,
                     percent_s.as_ptr(),
                     msg.as_ptr(),
diff --git a/rust/src/medium_level_il/function.rs b/rust/src/medium_level_il/function.rs
index de3ece02..75ccad82 100644
--- a/rust/src/medium_level_il/function.rs
+++ b/rust/src/medium_level_il/function.rs
@@ -1,5 +1,4 @@
 use binaryninjacore_sys::*;
-use std::ffi::c_char;
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
 
@@ -135,7 +134,7 @@ impl MediumLevelILFunction {
                 self.function().handle,
                 offset,
                 &mut owned_raw_var_ty,
-                name.as_ref().as_ptr() as *const c_char,
+                name.as_ptr(),
             )
         }
     }
@@ -282,13 +281,12 @@ impl MediumLevelILFunction {
     ) {
         let mut owned_raw_var_ty = Conf::<&Type>::into_raw(var_type.into());
         let name = name.to_cstr();
-        let name_c_str = name.as_ref();
         unsafe {
             BNCreateAutoStackVariable(
                 self.function().handle,
                 offset,
                 &mut owned_raw_var_ty,
-                name_c_str.as_ptr() as *const c_char,
+                name.as_ptr(),
             )
         }
     }
@@ -307,13 +305,12 @@ impl MediumLevelILFunction {
         let raw_var = BNVariable::from(var);
         let mut owned_raw_var_ty = Conf::<&Type>::into_raw(var_type.into());
         let name = name.to_cstr();
-        let name_c_str = name.as_ref();
         unsafe {
             BNCreateAutoVariable(
                 self.function().handle,
                 &raw_var,
                 &mut owned_raw_var_ty,
-                name_c_str.as_ptr() as *const c_char,
+                name.as_ptr(),
                 ignore_disjoint_uses,
             )
         }
diff --git a/rust/src/metadata.rs b/rust/src/metadata.rs
index c31e806b..cc10885a 100644
--- a/rust/src/metadata.rs
+++ b/rust/src/metadata.rs
@@ -271,12 +271,8 @@ impl Metadata {
         if self.get_type() != MetadataType::KeyValueDataType {
             return Err(());
         }
-        let ptr: *mut BNMetadata = unsafe {
-            BNMetadataGetForKey(
-                self.handle,
-                key.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let raw_key = key.to_cstr();
+        let ptr: *mut BNMetadata = unsafe { BNMetadataGetForKey(self.handle, raw_key.as_ptr()) };
         if ptr.is_null() {
             return Ok(None);
         }
@@ -295,14 +291,8 @@ impl Metadata {
         if self.get_type() != MetadataType::KeyValueDataType {
             return Err(());
         }
-
-        unsafe {
-            BNMetadataSetValueForKey(
-                self.handle,
-                key.to_cstr().as_ref().as_ptr() as *const c_char,
-                value.handle,
-            )
-        };
+        let raw_key = key.to_cstr();
+        unsafe { BNMetadataSetValueForKey(self.handle, raw_key.as_ptr(), value.handle) };
         Ok(())
     }
 
@@ -320,12 +310,8 @@ impl Metadata {
             return Err(());
         }
 
-        unsafe {
-            BNMetadataRemoveKey(
-                self.handle,
-                key.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let raw_key = key.to_cstr();
+        unsafe { BNMetadataRemoveKey(self.handle, raw_key.as_ptr()) };
         Ok(())
     }
 }
@@ -396,21 +382,15 @@ impl From<f64> for Ref<Metadata> {
 
 impl From<String> for Ref<Metadata> {
     fn from(value: String) -> Self {
-        unsafe {
-            Metadata::ref_from_raw(BNCreateMetadataStringData(
-                value.to_cstr().as_ptr() as *const c_char
-            ))
-        }
+        let raw_value = value.to_cstr();
+        unsafe { Metadata::ref_from_raw(BNCreateMetadataStringData(raw_value.as_ptr())) }
     }
 }
 
 impl From<&str> for Ref<Metadata> {
     fn from(value: &str) -> Self {
-        unsafe {
-            Metadata::ref_from_raw(BNCreateMetadataStringData(
-                value.to_cstr().as_ptr() as *const c_char
-            ))
-        }
+        let raw_value = value.to_cstr();
+        unsafe { Metadata::ref_from_raw(BNCreateMetadataStringData(raw_value.as_ptr())) }
     }
 }
 
@@ -448,10 +428,7 @@ impl<S: AsCStr> From<HashMap<S, Ref<Metadata>>> for Ref<Metadata> {
     fn from(value: HashMap<S, Ref<Metadata>>) -> Self {
         let data: Vec<(S::Result, Ref<Metadata>)> =
             value.into_iter().map(|(k, v)| (k.to_cstr(), v)).collect();
-        let mut keys: Vec<*const c_char> = data
-            .iter()
-            .map(|(k, _)| k.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut keys: Vec<*const c_char> = data.iter().map(|(k, _)| k.as_ptr()).collect();
         let mut values: Vec<*mut BNMetadata> = data.iter().map(|(_, v)| v.handle).collect();
 
         unsafe {
@@ -472,10 +449,7 @@ where
     fn from(value: &[(S, T)]) -> Self {
         let data: Vec<(S::Result, Ref<Metadata>)> =
             value.iter().map(|(k, v)| (k.to_cstr(), v.into())).collect();
-        let mut keys: Vec<*const c_char> = data
-            .iter()
-            .map(|(k, _)| k.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut keys: Vec<*const c_char> = data.iter().map(|(k, _)| k.as_ptr()).collect();
         let mut values: Vec<*mut BNMetadata> = data.iter().map(|(_, v)| v.handle).collect();
 
         unsafe {
@@ -552,7 +526,7 @@ impl<S: AsCStr> From<Vec<S>> for Ref<Metadata> {
         }
         let mut pointers = vec![];
         for r in &refs {
-            pointers.push(r.as_ref().as_ptr() as *const c_char);
+            pointers.push(r.as_ptr());
         }
         unsafe {
             Metadata::ref_from_raw(BNCreateMetadataStringListData(
diff --git a/rust/src/platform.rs b/rust/src/platform.rs
index 19186740..c225392f 100644
--- a/rust/src/platform.rs
+++ b/rust/src/platform.rs
@@ -85,7 +85,7 @@ impl Platform {
     pub fn by_name<S: AsCStr>(name: S) -> Option<Ref<Self>> {
         let raw_name = name.to_cstr();
         unsafe {
-            let res = BNGetPlatformByName(raw_name.as_ref().as_ptr() as *mut _);
+            let res = BNGetPlatformByName(raw_name.as_ptr());
 
             if res.is_null() {
                 None
@@ -118,7 +118,7 @@ impl Platform {
 
         unsafe {
             let mut count = 0;
-            let handles = BNGetPlatformListByOS(raw_name.as_ref().as_ptr() as *mut _, &mut count);
+            let handles = BNGetPlatformListByOS(raw_name.as_ptr(), &mut count);
 
             Array::new(handles, count, ())
         }
@@ -129,11 +129,8 @@ impl Platform {
 
         unsafe {
             let mut count = 0;
-            let handles = BNGetPlatformListByOSAndArchitecture(
-                raw_name.as_ref().as_ptr() as *mut _,
-                arch.handle,
-                &mut count,
-            );
+            let handles =
+                BNGetPlatformListByOSAndArchitecture(raw_name.as_ptr(), arch.handle, &mut count);
 
             Array::new(handles, count, ())
         }
@@ -151,7 +148,7 @@ impl Platform {
     pub fn new<A: Architecture, S: AsCStr>(arch: &A, name: S) -> Ref<Self> {
         let name = name.to_cstr();
         unsafe {
-            let handle = BNCreatePlatform(arch.as_ref().handle, name.as_ref().as_ptr() as *mut _);
+            let handle = BNCreatePlatform(arch.as_ref().handle, name.as_ptr());
             assert!(!handle.is_null());
             Ref::new(Self { handle })
         }
@@ -179,13 +176,8 @@ impl Platform {
     pub fn get_type_libraries_by_name<T: AsCStr>(&self, name: T) -> Array<TypeLibrary> {
         let mut count = 0;
         let name = name.to_cstr();
-        let result = unsafe {
-            BNGetPlatformTypeLibrariesByName(
-                self.handle,
-                name.as_ref().as_ptr() as *mut _,
-                &mut count,
-            )
-        };
+        let result =
+            unsafe { BNGetPlatformTypeLibrariesByName(self.handle, name.as_ptr(), &mut count) };
         assert!(!result.is_null());
         unsafe { Array::new(result, count, ()) }
     }
@@ -194,7 +186,7 @@ impl Platform {
         let os = os.to_cstr();
 
         unsafe {
-            BNRegisterPlatform(os.as_ref().as_ptr() as *mut _, self.handle);
+            BNRegisterPlatform(os.as_ptr(), self.handle);
         }
     }
 
diff --git a/rust/src/project.rs b/rust/src/project.rs
index 453f1c56..351b6e3f 100644
--- a/rust/src/project.rs
+++ b/rust/src/project.rs
@@ -1,7 +1,7 @@
 pub mod file;
 pub mod folder;
 
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::fmt::Debug;
 use std::ptr::{null_mut, NonNull};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -42,12 +42,7 @@ impl Project {
     pub fn create<P: AsCStr, S: AsCStr>(path: P, name: S) -> Option<Ref<Self>> {
         let path_raw = path.to_cstr();
         let name_raw = name.to_cstr();
-        let handle = unsafe {
-            BNCreateProject(
-                path_raw.as_ref().as_ptr() as *const c_char,
-                name_raw.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let handle = unsafe { BNCreateProject(path_raw.as_ptr(), name_raw.as_ptr()) };
         NonNull::new(handle).map(|h| unsafe { Self::ref_from_raw(h) })
     }
 
@@ -56,7 +51,7 @@ impl Project {
     /// * `path` - Path to the project directory (.bnpr) or project metadata file (.bnpm)
     pub fn open_project<P: AsCStr>(path: P) -> Option<Ref<Self>> {
         let path_raw = path.to_cstr();
-        let handle = unsafe { BNOpenProject(path_raw.as_ref().as_ptr() as *const c_char) };
+        let handle = unsafe { BNOpenProject(path_raw.as_ptr()) };
         NonNull::new(handle).map(|h| unsafe { Self::ref_from_raw(h) })
     }
 
@@ -101,12 +96,7 @@ impl Project {
     /// Set the name of the project
     pub fn set_name<S: AsCStr>(&self, value: S) {
         let value = value.to_cstr();
-        unsafe {
-            BNProjectSetName(
-                self.handle.as_ptr(),
-                value.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectSetName(self.handle.as_ptr(), value.as_ptr()) }
     }
 
     /// Get the description of the project
@@ -117,20 +107,13 @@ impl Project {
     /// Set the description of the project
     pub fn set_description<S: AsCStr>(&self, value: S) {
         let value = value.to_cstr();
-        unsafe {
-            BNProjectSetDescription(
-                self.handle.as_ptr(),
-                value.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectSetDescription(self.handle.as_ptr(), value.as_ptr()) }
     }
 
     /// Retrieves metadata stored under a key from the project
     pub fn query_metadata<S: AsCStr>(&self, key: S) -> Ref<Metadata> {
         let key = key.to_cstr();
-        let result = unsafe {
-            BNProjectQueryMetadata(self.handle.as_ptr(), key.as_ref().as_ptr() as *const c_char)
-        };
+        let result = unsafe { BNProjectQueryMetadata(self.handle.as_ptr(), key.as_ptr()) };
         unsafe { Metadata::ref_from_raw(result) }
     }
 
@@ -140,24 +123,13 @@ impl Project {
     /// * `value` - Object to store
     pub fn store_metadata<S: AsCStr>(&self, key: S, value: &Metadata) -> bool {
         let key_raw = key.to_cstr();
-        unsafe {
-            BNProjectStoreMetadata(
-                self.handle.as_ptr(),
-                key_raw.as_ref().as_ptr() as *const c_char,
-                value.handle,
-            )
-        }
+        unsafe { BNProjectStoreMetadata(self.handle.as_ptr(), key_raw.as_ptr(), value.handle) }
     }
 
     /// Removes the metadata associated with this `key` from the project
     pub fn remove_metadata<S: AsCStr>(&self, key: S) {
         let key_raw = key.to_cstr();
-        unsafe {
-            BNProjectRemoveMetadata(
-                self.handle.as_ptr(),
-                key_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectRemoveMetadata(self.handle.as_ptr(), key_raw.as_ptr()) }
     }
 
     pub fn push_folder(&self, file: &ProjectFolder) {
@@ -207,9 +179,9 @@ impl Project {
         unsafe {
             let result = BNProjectCreateFolderFromPath(
                 self.handle.as_ptr(),
-                path_raw.as_ref().as_ptr() as *const c_char,
+                path_raw.as_ptr(),
                 parent_ptr,
-                description_raw.as_ref().as_ptr() as *const c_char,
+                description_raw.as_ptr(),
                 &mut progress as *mut PC as *mut c_void,
                 Some(PC::cb_progress_callback),
             );
@@ -239,8 +211,8 @@ impl Project {
             let result = BNProjectCreateFolder(
                 self.handle.as_ptr(),
                 parent_ptr,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                description_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
+                description_raw.as_ptr(),
             );
             Ok(ProjectFolder::ref_from_raw(NonNull::new(result).ok_or(())?))
         }
@@ -272,9 +244,9 @@ impl Project {
             let result = BNProjectCreateFolderUnsafe(
                 self.handle.as_ptr(),
                 parent_ptr,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                description_raw.as_ref().as_ptr() as *const c_char,
-                id_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
+                description_raw.as_ptr(),
+                id_raw.as_ptr(),
             );
             Ok(ProjectFolder::ref_from_raw(NonNull::new(result).ok_or(())?))
         }
@@ -293,9 +265,8 @@ impl Project {
 
     /// Retrieve a folder in the project by unique folder `id`
     pub fn folder_by_id<S: AsCStr>(&self, id: S) -> Option<Ref<ProjectFolder>> {
-        let id_raw = id.to_cstr();
-        let id_ptr = id_raw.as_ref().as_ptr() as *const c_char;
-        let result = unsafe { BNProjectGetFolderById(self.handle.as_ptr(), id_ptr) };
+        let raw_id = id.to_cstr();
+        let result = unsafe { BNProjectGetFolderById(self.handle.as_ptr(), raw_id.as_ptr()) };
         let handle = NonNull::new(result)?;
         Some(unsafe { ProjectFolder::ref_from_raw(handle) })
     }
@@ -392,10 +363,10 @@ impl Project {
         unsafe {
             let result = BNProjectCreateFileFromPath(
                 self.handle.as_ptr(),
-                path_raw.as_ref().as_ptr() as *const c_char,
+                path_raw.as_ptr(),
                 folder_ptr,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                description_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
+                description_raw.as_ptr(),
                 &mut progress as *mut PC as *mut c_void,
                 Some(PC::cb_progress_callback),
             );
@@ -473,11 +444,11 @@ impl Project {
         unsafe {
             let result = BNProjectCreateFileFromPathUnsafe(
                 self.handle.as_ptr(),
-                path_raw.as_ref().as_ptr() as *const c_char,
+                path_raw.as_ptr(),
                 folder_ptr,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                description_raw.as_ref().as_ptr() as *const c_char,
-                id_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
+                description_raw.as_ptr(),
+                id_raw.as_ptr(),
                 systime_to_bntime(creation_time).unwrap(),
                 &mut progress as *mut PC as *mut c_void,
                 Some(PC::cb_progress_callback),
@@ -536,8 +507,8 @@ impl Project {
                 contents.as_ptr(),
                 contents.len(),
                 folder_ptr,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                description_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
+                description_raw.as_ptr(),
                 &mut progress as *mut P as *mut c_void,
                 Some(P::cb_progress_callback),
             );
@@ -615,9 +586,9 @@ impl Project {
                 contents.as_ptr(),
                 contents.len(),
                 folder_ptr,
-                name_raw.as_ref().as_ptr() as *const c_char,
-                description_raw.as_ref().as_ptr() as *const c_char,
-                id_raw.as_ref().as_ptr() as *const c_char,
+                name_raw.as_ptr(),
+                description_raw.as_ptr(),
+                id_raw.as_ptr(),
                 systime_to_bntime(creation_time).unwrap(),
                 &mut progress as *mut P as *mut c_void,
                 Some(P::cb_progress_callback),
@@ -636,10 +607,8 @@ impl Project {
 
     /// Retrieve a file in the project by unique `id`
     pub fn file_by_id<S: AsCStr>(&self, id: S) -> Option<Ref<ProjectFile>> {
-        let id_raw = id.to_cstr();
-        let id_ptr = id_raw.as_ref().as_ptr() as *const c_char;
-
-        let result = unsafe { BNProjectGetFileById(self.handle.as_ptr(), id_ptr) };
+        let raw_id = id.to_cstr();
+        let result = unsafe { BNProjectGetFileById(self.handle.as_ptr(), raw_id.as_ptr()) };
         let handle = NonNull::new(result)?;
         Some(unsafe { ProjectFile::ref_from_raw(handle) })
     }
@@ -647,9 +616,8 @@ impl Project {
     /// Retrieve a file in the project by the `path` on disk
     pub fn file_by_path<S: AsCStr>(&self, path: S) -> Option<Ref<ProjectFile>> {
         let path_raw = path.to_cstr();
-        let path_ptr = path_raw.as_ref().as_ptr() as *const c_char;
-
-        let result = unsafe { BNProjectGetFileByPathOnDisk(self.handle.as_ptr(), path_ptr) };
+        let result =
+            unsafe { BNProjectGetFileByPathOnDisk(self.handle.as_ptr(), path_raw.as_ptr()) };
         let handle = NonNull::new(result)?;
         Some(unsafe { ProjectFile::ref_from_raw(handle) })
     }
diff --git a/rust/src/project/file.rs b/rust/src/project/file.rs
index d1724ab0..bc486ed9 100644
--- a/rust/src/project/file.rs
+++ b/rust/src/project/file.rs
@@ -8,7 +8,6 @@ use binaryninjacore_sys::{
     BNProjectFileGetPathOnDisk, BNProjectFileGetProject, BNProjectFileSetDescription,
     BNProjectFileSetFolder, BNProjectFileSetName,
 };
-use std::ffi::c_char;
 use std::fmt::Debug;
 use std::ptr::{null_mut, NonNull};
 use std::time::SystemTime;
@@ -59,12 +58,7 @@ impl ProjectFile {
     /// Set the name of this file
     pub fn set_name<S: AsCStr>(&self, value: S) -> bool {
         let value_raw = value.to_cstr();
-        unsafe {
-            BNProjectFileSetName(
-                self.handle.as_ptr(),
-                value_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectFileSetName(self.handle.as_ptr(), value_raw.as_ptr()) }
     }
 
     /// Get the description of this file
@@ -75,12 +69,7 @@ impl ProjectFile {
     /// Set the description of this file
     pub fn set_description<S: AsCStr>(&self, value: S) -> bool {
         let value_raw = value.to_cstr();
-        unsafe {
-            BNProjectFileSetDescription(
-                self.handle.as_ptr(),
-                value_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectFileSetDescription(self.handle.as_ptr(), value_raw.as_ptr()) }
     }
 
     /// Get the file creation time
@@ -106,12 +95,7 @@ impl ProjectFile {
     /// * `dest` - Destination path for the exported contents
     pub fn export<S: AsCStr>(&self, dest: S) -> bool {
         let dest_raw = dest.to_cstr();
-        unsafe {
-            BNProjectFileExport(
-                self.handle.as_ptr(),
-                dest_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectFileExport(self.handle.as_ptr(), dest_raw.as_ptr()) }
     }
 }
 
diff --git a/rust/src/project/folder.rs b/rust/src/project/folder.rs
index b8881ddc..80416197 100644
--- a/rust/src/project/folder.rs
+++ b/rust/src/project/folder.rs
@@ -8,7 +8,7 @@ use binaryninjacore_sys::{
     BNProjectFolderGetName, BNProjectFolderGetParent, BNProjectFolderGetProject,
     BNProjectFolderSetDescription, BNProjectFolderSetName, BNProjectFolderSetParent,
 };
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::fmt::Debug;
 use std::ptr::{null_mut, NonNull};
 
@@ -48,12 +48,7 @@ impl ProjectFolder {
     /// Set the name of this folder
     pub fn set_name<S: AsCStr>(&self, value: S) -> bool {
         let value_raw = value.to_cstr();
-        unsafe {
-            BNProjectFolderSetName(
-                self.handle.as_ptr(),
-                value_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectFolderSetName(self.handle.as_ptr(), value_raw.as_ptr()) }
     }
 
     /// Get the description of this folder
@@ -64,12 +59,7 @@ impl ProjectFolder {
     /// Set the description of this folder
     pub fn set_description<S: AsCStr>(&self, value: S) -> bool {
         let value_raw = value.to_cstr();
-        unsafe {
-            BNProjectFolderSetDescription(
-                self.handle.as_ptr(),
-                value_raw.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNProjectFolderSetDescription(self.handle.as_ptr(), value_raw.as_ptr()) }
     }
 
     /// Get the folder that contains this folder
@@ -107,7 +97,7 @@ impl ProjectFolder {
         let success = unsafe {
             BNProjectFolderExport(
                 self.handle.as_ptr(),
-                dest_raw.as_ref().as_ptr() as *const c_char,
+                dest_raw.as_ptr(),
                 &mut progress as *mut P as *mut c_void,
                 Some(P::cb_progress_callback),
             )
diff --git a/rust/src/render_layer.rs b/rust/src/render_layer.rs
index 175ee167..7d792491 100644
--- a/rust/src/render_layer.rs
+++ b/rust/src/render_layer.rs
@@ -8,7 +8,7 @@ use crate::linear_view::{LinearDisassemblyLine, LinearDisassemblyLineType, Linea
 use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner};
 use crate::string::AsCStr;
 use binaryninjacore_sys::*;
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::ptr::NonNull;
 
 /// The state in which the [`RenderLayer`] will be registered with.
@@ -73,13 +73,9 @@ pub fn register_render_layer<S: AsCStr, T: RenderLayer>(
         applyToLinearViewObject: Some(cb_apply_to_linear_view_object::<T>),
         freeLines: Some(cb_free_lines),
     };
-    let result = unsafe {
-        BNRegisterRenderLayer(
-            name.to_cstr().as_ref().as_ptr() as *const _,
-            &mut callback,
-            default_state.into(),
-        )
-    };
+    let name = name.to_cstr();
+    let result =
+        unsafe { BNRegisterRenderLayer(name.as_ptr(), &mut callback, default_state.into()) };
     let core = CoreRenderLayer::from_raw(NonNull::new(result).unwrap());
     (render_layer, core)
 }
@@ -305,7 +301,7 @@ impl CoreRenderLayer {
 
     pub fn render_layer_by_name<S: AsCStr>(name: S) -> Option<CoreRenderLayer> {
         let name_raw = name.to_cstr();
-        let result = unsafe { BNGetRenderLayerByName(name_raw.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNGetRenderLayerByName(name_raw.as_ptr()) };
         NonNull::new(result).map(Self::from_raw)
     }
 
diff --git a/rust/src/repository.rs b/rust/src/repository.rs
index 8d2fbafe..27825b96 100644
--- a/rust/src/repository.rs
+++ b/rust/src/repository.rs
@@ -54,12 +54,7 @@ impl Repository {
 
     pub fn plugin_by_path<S: AsCStr>(&self, path: S) -> Option<Ref<RepositoryPlugin>> {
         let path = path.to_cstr();
-        let result = unsafe {
-            BNRepositoryGetPluginByPath(
-                self.handle.as_ptr(),
-                path.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNRepositoryGetPluginByPath(self.handle.as_ptr(), path.as_ptr()) };
         NonNull::new(result).map(|h| unsafe { RepositoryPlugin::ref_from_raw(h) })
     }
 
diff --git a/rust/src/repository/manager.rs b/rust/src/repository/manager.rs
index e5911802..29c73605 100644
--- a/rust/src/repository/manager.rs
+++ b/rust/src/repository/manager.rs
@@ -7,7 +7,6 @@ use binaryninjacore_sys::{
     BNRepositoryManagerAddRepository, BNRepositoryManagerCheckForUpdates,
     BNRepositoryManagerGetDefaultRepository, BNRepositoryManagerGetRepositories,
 };
-use std::ffi::c_char;
 use std::fmt::Debug;
 use std::ptr::NonNull;
 
@@ -31,8 +30,7 @@ impl RepositoryManager {
 
     pub fn new<S: AsCStr>(plugins_path: S) -> Ref<Self> {
         let plugins_path = plugins_path.to_cstr();
-        let result =
-            unsafe { BNCreateRepositoryManager(plugins_path.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNCreateRepositoryManager(plugins_path.as_ptr()) };
         unsafe { Self::ref_from_raw(NonNull::new(result).unwrap()) }
     }
 
@@ -65,22 +63,14 @@ impl RepositoryManager {
         let url = url.to_cstr();
         let repo_path = repository_path.to_cstr();
         unsafe {
-            BNRepositoryManagerAddRepository(
-                self.handle.as_ptr(),
-                url.as_ref().as_ptr() as *const c_char,
-                repo_path.as_ref().as_ptr() as *const c_char,
-            )
+            BNRepositoryManagerAddRepository(self.handle.as_ptr(), url.as_ptr(), repo_path.as_ptr())
         }
     }
 
     pub fn repository_by_path<P: AsCStr>(&self, path: P) -> Option<Repository> {
         let path = path.to_cstr();
-        let result = unsafe {
-            BNRepositoryGetRepositoryByPath(
-                self.handle.as_ptr(),
-                path.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result =
+            unsafe { BNRepositoryGetRepositoryByPath(self.handle.as_ptr(), path.as_ptr()) };
         NonNull::new(result).map(|raw| unsafe { Repository::from_raw(raw) })
     }
 
diff --git a/rust/src/secrets_provider.rs b/rust/src/secrets_provider.rs
index 7acf6d4b..7a807300 100644
--- a/rust/src/secrets_provider.rs
+++ b/rust/src/secrets_provider.rs
@@ -37,7 +37,7 @@ impl CoreSecretsProvider {
             deleteData: Some(cb_delete_data::<C>),
         };
         let result =
-            unsafe { BNRegisterSecretsProvider(name.as_ptr() as *const c_char, &mut callbacks) };
+            unsafe { BNRegisterSecretsProvider(name.as_ptr(), &mut callbacks) };
         unsafe { Self::from_raw(NonNull::new(result).unwrap()) }
     }
 
@@ -52,7 +52,7 @@ impl CoreSecretsProvider {
     /// Retrieve a provider by name
     pub fn by_name<S: AsCStr>(name: S) -> Option<CoreSecretsProvider> {
         let name = name.to_cstr();
-        let result = unsafe { BNGetSecretsProviderByName(name.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNGetSecretsProviderByName(name.as_ptr()) };
         NonNull::new(result).map(|h| unsafe { Self::from_raw(h) })
     }
 
@@ -65,17 +65,13 @@ impl CoreSecretsProvider {
     /// Check if data for a specific key exists, but do not retrieve it
     pub fn has_data<S: AsCStr>(&self, key: S) -> bool {
         let key = key.to_cstr();
-        unsafe {
-            BNSecretsProviderHasData(self.handle.as_ptr(), key.as_ref().as_ptr() as *const c_char)
-        }
+        unsafe { BNSecretsProviderHasData(self.handle.as_ptr(), key.as_ptr()) }
     }
 
     /// Retrieve data for the given key, if it exists
     pub fn get_data<S: AsCStr>(&self, key: S) -> String {
         let key = key.to_cstr();
-        let result = unsafe {
-            BNGetSecretsProviderData(self.handle.as_ptr(), key.as_ref().as_ptr() as *const c_char)
-        };
+        let result = unsafe { BNGetSecretsProviderData(self.handle.as_ptr(), key.as_ptr()) };
         unsafe { BnString::into_string(result) }
     }
 
@@ -83,24 +79,13 @@ impl CoreSecretsProvider {
     pub fn store_data<K: AsCStr, V: AsCStr>(&self, key: K, value: V) -> bool {
         let key = key.to_cstr();
         let value = value.to_cstr();
-        unsafe {
-            BNStoreSecretsProviderData(
-                self.handle.as_ptr(),
-                key.as_ref().as_ptr() as *const c_char,
-                value.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNStoreSecretsProviderData(self.handle.as_ptr(), key.as_ptr(), value.as_ptr()) }
     }
 
     /// Delete stored data with the given key
     pub fn delete_data<S: AsCStr>(&self, key: S) -> bool {
         let key = key.to_cstr();
-        unsafe {
-            BNDeleteSecretsProviderData(
-                self.handle.as_ptr(),
-                key.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNDeleteSecretsProviderData(self.handle.as_ptr(), key.as_ptr()) }
     }
 }
 
diff --git a/rust/src/section.rs b/rust/src/section.rs
index d1098e67..53afffb3 100644
--- a/rust/src/section.rs
+++ b/rust/src/section.rs
@@ -14,7 +14,6 @@
 
 //! Sections are [crate::segment::Segment]s that are loaded into memory at run time
 
-use std::ffi::c_char;
 use std::fmt;
 use std::ops::Range;
 
@@ -282,29 +281,29 @@ impl SectionBuilder {
             if self.is_auto {
                 BNAddAutoSection(
                     view.handle,
-                    name.as_ptr() as *const c_char,
+                    name.as_ptr(),
                     start,
                     len,
                     self.semantics.into(),
-                    ty.as_ptr() as *const c_char,
+                    ty.as_ptr(),
                     self.align,
                     self.entry_size,
-                    linked_section.as_ptr() as *const c_char,
-                    info_section.as_ptr() as *const c_char,
+                    linked_section.as_ptr(),
+                    info_section.as_ptr(),
                     self.info_data,
                 );
             } else {
                 BNAddUserSection(
                     view.handle,
-                    name.as_ptr() as *const c_char,
+                    name.as_ptr(),
                     start,
                     len,
                     self.semantics.into(),
-                    ty.as_ptr() as *const c_char,
+                    ty.as_ptr(),
                     self.align,
                     self.entry_size,
-                    linked_section.as_ptr() as *const c_char,
-                    info_section.as_ptr() as *const c_char,
+                    linked_section.as_ptr(),
+                    info_section.as_ptr(),
                     self.info_data,
                 );
             }
diff --git a/rust/src/settings.rs b/rust/src/settings.rs
index b49dbdea..be2fd955 100644
--- a/rust/src/settings.rs
+++ b/rust/src/settings.rs
@@ -47,7 +47,7 @@ impl Settings {
     pub fn new_with_id<S: AsCStr>(instance_id: S) -> Ref<Self> {
         let instance_id = instance_id.to_cstr();
         unsafe {
-            let handle = BNCreateSettings(instance_id.as_ref().as_ptr() as *mut _);
+            let handle = BNCreateSettings(instance_id.as_ptr());
             debug_assert!(!handle.is_null());
             Ref::new(Self { handle })
         }
@@ -55,7 +55,7 @@ impl Settings {
 
     pub fn set_resource_id<S: AsCStr>(&self, resource_id: S) {
         let resource_id = resource_id.to_cstr();
-        unsafe { BNSettingsSetResourceId(self.handle, resource_id.as_ref().as_ptr() as *mut _) };
+        unsafe { BNSettingsSetResourceId(self.handle, resource_id.as_ptr()) };
     }
 
     pub fn serialize_schema(&self) -> String {
@@ -72,20 +72,13 @@ impl Settings {
         scope: SettingsScope,
     ) -> bool {
         let schema = schema.to_cstr();
-        unsafe {
-            BNSettingsDeserializeSchema(
-                self.handle,
-                schema.as_ref().as_ptr() as *mut _,
-                scope,
-                true,
-            )
-        }
+        unsafe { BNSettingsDeserializeSchema(self.handle, schema.as_ptr(), scope, true) }
     }
 
     pub fn contains<S: AsCStr>(&self, key: S) -> bool {
         let key = key.to_cstr();
 
-        unsafe { BNSettingsContains(self.handle, key.as_ref().as_ptr() as *mut _) }
+        unsafe { BNSettingsContains(self.handle, key.as_ptr()) }
     }
 
     pub fn keys(&self) -> Array<BnString> {
@@ -114,7 +107,7 @@ impl Settings {
         unsafe {
             BNSettingsGetBool(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 view_ptr,
                 func_ptr,
                 &mut options.scope,
@@ -139,7 +132,7 @@ impl Settings {
         unsafe {
             BNSettingsGetDouble(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 view_ptr,
                 func_ptr,
                 &mut options.scope,
@@ -164,7 +157,7 @@ impl Settings {
         unsafe {
             BNSettingsGetUInt64(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 view_ptr,
                 func_ptr,
                 &mut options.scope,
@@ -189,7 +182,7 @@ impl Settings {
         unsafe {
             BnString::into_string(BNSettingsGetString(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 view_ptr,
                 func_ptr,
                 &mut options.scope,
@@ -220,7 +213,7 @@ impl Settings {
             Array::new(
                 BNSettingsGetStringList(
                     self.handle,
-                    key.as_ref().as_ptr() as *mut _,
+                    key.as_ptr(),
                     view_ptr,
                     func_ptr,
                     &mut options.scope,
@@ -249,7 +242,7 @@ impl Settings {
         unsafe {
             BnString::into_string(BNSettingsGetJson(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 view_ptr,
                 func_ptr,
                 &mut options.scope,
@@ -277,7 +270,7 @@ impl Settings {
                 view_ptr,
                 func_ptr,
                 options.scope,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 value,
             );
         }
@@ -302,7 +295,7 @@ impl Settings {
                 view_ptr,
                 func_ptr,
                 options.scope,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 value,
             );
         }
@@ -328,7 +321,7 @@ impl Settings {
                 view_ptr,
                 func_ptr,
                 options.scope,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 value,
             );
         }
@@ -360,8 +353,8 @@ impl Settings {
                 view_ptr,
                 func_ptr,
                 options.scope,
-                key.as_ref().as_ptr() as *mut _,
-                value.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
+                value.as_ptr(),
             );
         }
     }
@@ -382,10 +375,7 @@ impl Settings {
     ) -> bool {
         let key = key.to_cstr();
         let raw_list: Vec<_> = value.map(|s| s.to_cstr()).collect();
-        let mut raw_list_ptr: Vec<_> = raw_list
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut raw_list_ptr: Vec<_> = raw_list.iter().map(|s| s.as_ptr()).collect();
 
         let view_ptr = match options.view.as_ref() {
             Some(view) => view.handle,
@@ -401,7 +391,7 @@ impl Settings {
                 view_ptr,
                 func_ptr,
                 options.scope,
-                key.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
                 raw_list_ptr.as_mut_ptr(),
                 raw_list_ptr.len(),
             )
@@ -434,8 +424,8 @@ impl Settings {
                 view_ptr,
                 func_ptr,
                 options.scope,
-                key.as_ref().as_ptr() as *mut _,
-                value.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
+                value.as_ptr(),
             )
         }
     }
@@ -446,8 +436,8 @@ impl Settings {
         unsafe {
             BnString::into_string(BNSettingsQueryPropertyString(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
-                property.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
+                property.as_ptr(),
             ))
         }
     }
@@ -460,8 +450,8 @@ impl Settings {
             Array::new(
                 BNSettingsQueryPropertyStringList(
                     self.handle,
-                    key.as_ref().as_ptr() as *mut _,
-                    property.as_ref().as_ptr() as *mut _,
+                    key.as_ptr(),
+                    property.as_ptr(),
                     &mut size,
                 ) as *mut *mut c_char,
                 size,
@@ -474,12 +464,7 @@ impl Settings {
         let key = key.to_cstr();
         let property = property.to_cstr();
         unsafe {
-            BNSettingsUpdateBoolProperty(
-                self.handle,
-                key.as_ref().as_ptr() as *mut _,
-                property.as_ref().as_ptr() as *mut _,
-                value,
-            );
+            BNSettingsUpdateBoolProperty(self.handle, key.as_ptr(), property.as_ptr(), value);
         }
     }
 
@@ -487,12 +472,7 @@ impl Settings {
         let key = key.to_cstr();
         let property = property.to_cstr();
         unsafe {
-            BNSettingsUpdateUInt64Property(
-                self.handle,
-                key.as_ref().as_ptr() as *mut _,
-                property.as_ref().as_ptr() as *mut _,
-                value,
-            );
+            BNSettingsUpdateUInt64Property(self.handle, key.as_ptr(), property.as_ptr(), value);
         }
     }
 
@@ -500,12 +480,7 @@ impl Settings {
         let key = key.to_cstr();
         let property = property.to_cstr();
         unsafe {
-            BNSettingsUpdateDoubleProperty(
-                self.handle,
-                key.as_ref().as_ptr() as *mut _,
-                property.as_ref().as_ptr() as *mut _,
-                value,
-            );
+            BNSettingsUpdateDoubleProperty(self.handle, key.as_ptr(), property.as_ptr(), value);
         }
     }
 
@@ -516,9 +491,9 @@ impl Settings {
         unsafe {
             BNSettingsUpdateStringProperty(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
-                property.as_ref().as_ptr() as *mut _,
-                value.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
+                property.as_ptr(),
+                value.as_ptr(),
             );
         }
     }
@@ -532,16 +507,13 @@ impl Settings {
         let key = key.to_cstr();
         let property = property.to_cstr();
         let raw_list: Vec<_> = value.map(|s| s.to_cstr()).collect();
-        let mut raw_list_ptr: Vec<_> = raw_list
-            .iter()
-            .map(|s| s.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut raw_list_ptr: Vec<_> = raw_list.iter().map(|s| s.as_ptr()).collect();
 
         unsafe {
             BNSettingsUpdateStringListProperty(
                 self.handle,
-                key.as_ref().as_ptr() as *mut _,
-                property.as_ref().as_ptr() as *mut _,
+                key.as_ptr(),
+                property.as_ptr(),
                 raw_list_ptr.as_mut_ptr(),
                 raw_list_ptr.len(),
             );
@@ -552,26 +524,14 @@ impl Settings {
         let group = group.to_cstr();
         let title = title.to_cstr();
 
-        unsafe {
-            BNSettingsRegisterGroup(
-                self.handle,
-                group.as_ref().as_ptr() as *mut _,
-                title.as_ref().as_ptr() as *mut _,
-            )
-        }
+        unsafe { BNSettingsRegisterGroup(self.handle, group.as_ptr(), title.as_ptr()) }
     }
 
     pub fn register_setting_json<S1: AsCStr, S2: AsCStr>(&self, group: S1, properties: S2) -> bool {
         let group = group.to_cstr();
         let properties = properties.to_cstr();
 
-        unsafe {
-            BNSettingsRegisterSetting(
-                self.handle,
-                group.as_ref().as_ptr() as *mut _,
-                properties.as_ref().as_ptr() as *mut _,
-            )
-        }
+        unsafe { BNSettingsRegisterSetting(self.handle, group.as_ptr(), properties.as_ptr()) }
     }
 
     // TODO: register_setting but type-safely turn it into json
diff --git a/rust/src/string.rs b/rust/src/string.rs
index 17fcf911..640731ff 100644
--- a/rust/src/string.rs
+++ b/rust/src/string.rs
@@ -23,6 +23,7 @@ use std::hash::{Hash, Hasher};
 use std::mem;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
+use crate::type_archive::TypeArchiveSnapshotId;
 
 // TODO: Remove or refactor this.
 pub(crate) fn raw_to_string(ptr: *const c_char) -> Option<String> {
@@ -291,6 +292,14 @@ unsafe impl AsCStr for &Path {
     }
 }
 
+unsafe impl AsCStr for TypeArchiveSnapshotId {
+    type Result = CString;
+    
+    fn to_cstr(self) -> Self::Result {
+        self.to_string().to_cstr()
+    }   
+}
+
 pub trait IntoJson {
     type Output: AsCStr;
 
diff --git a/rust/src/tags.rs b/rust/src/tags.rs
index 30cc4682..72cae705 100644
--- a/rust/src/tags.rs
+++ b/rust/src/tags.rs
@@ -44,7 +44,7 @@ impl Tag {
 
     pub fn new<S: AsCStr>(t: &TagType, data: S) -> Ref<Self> {
         let data = data.to_cstr();
-        unsafe { Self::ref_from_raw(BNCreateTag(t.handle, data.as_ref().as_ptr() as *mut _)) }
+        unsafe { Self::ref_from_raw(BNCreateTag(t.handle, data.as_ptr())) }
     }
 
     pub fn id(&self) -> String {
@@ -62,7 +62,7 @@ impl Tag {
     pub fn set_data<S: AsCStr>(&self, data: S) {
         let data = data.to_cstr();
         unsafe {
-            BNTagSetData(self.handle, data.as_ref().as_ptr() as *mut _);
+            BNTagSetData(self.handle, data.as_ptr());
         }
     }
 }
@@ -152,7 +152,7 @@ impl TagType {
     pub fn set_icon<S: AsCStr>(&self, icon: S) {
         let icon = icon.to_cstr();
         unsafe {
-            BNTagTypeSetIcon(self.handle, icon.as_ref().as_ptr() as *mut _);
+            BNTagTypeSetIcon(self.handle, icon.as_ptr());
         }
     }
 
@@ -163,7 +163,7 @@ impl TagType {
     pub fn set_name<S: AsCStr>(&self, name: S) {
         let name = name.to_cstr();
         unsafe {
-            BNTagTypeSetName(self.handle, name.as_ref().as_ptr() as *mut _);
+            BNTagTypeSetName(self.handle, name.as_ptr());
         }
     }
 
@@ -182,7 +182,7 @@ impl TagType {
     pub fn set_type<S: AsCStr>(&self, t: S) {
         let t = t.to_cstr();
         unsafe {
-            BNTagTypeSetName(self.handle, t.as_ref().as_ptr() as *mut _);
+            BNTagTypeSetName(self.handle, t.as_ptr());
         }
     }
 
diff --git a/rust/src/template_simplifier.rs b/rust/src/template_simplifier.rs
index 57d2b0b4..c9e54e72 100644
--- a/rust/src/template_simplifier.rs
+++ b/rust/src/template_simplifier.rs
@@ -6,15 +6,10 @@ use binaryninjacore_sys::{BNRustSimplifyStrToFQN, BNRustSimplifyStrToStr};
 
 pub fn simplify_str_to_str<S: AsCStr>(input: S) -> BnString {
     let name = input.to_cstr();
-    unsafe { BnString::from_raw(BNRustSimplifyStrToStr(name.as_ref().as_ptr() as *mut _)) }
+    unsafe { BnString::from_raw(BNRustSimplifyStrToStr(name.as_ptr())) }
 }
 
 pub fn simplify_str_to_fqn<S: AsCStr>(input: S, simplify: bool) -> QualifiedName {
     let name = input.to_cstr();
-    unsafe {
-        QualifiedName::from_owned_raw(BNRustSimplifyStrToFQN(
-            name.as_ref().as_ptr() as *mut _,
-            simplify,
-        ))
-    }
+    unsafe { QualifiedName::from_owned_raw(BNRustSimplifyStrToFQN(name.as_ptr(), simplify)) }
 }
diff --git a/rust/src/type_archive.rs b/rust/src/type_archive.rs
index 5e94f19e..2daca983 100644
--- a/rust/src/type_archive.rs
+++ b/rust/src/type_archive.rs
@@ -66,7 +66,7 @@ impl TypeArchive {
     /// Open the Type Archive at the given path, if it exists.
     pub fn open(path: impl AsRef<Path>) -> Option<Ref<TypeArchive>> {
         let raw_path = path.as_ref().to_cstr();
-        let handle = unsafe { BNOpenTypeArchive(raw_path.as_ptr() as *const c_char) };
+        let handle = unsafe { BNOpenTypeArchive(raw_path.as_ptr()) };
         NonNull::new(handle).map(|handle| unsafe { TypeArchive::ref_from_raw(handle) })
     }
 
@@ -76,7 +76,7 @@ impl TypeArchive {
     pub fn create(path: impl AsRef<Path>, platform: &Platform) -> Option<Ref<TypeArchive>> {
         let raw_path = path.as_ref().to_cstr();
         let handle =
-            unsafe { BNCreateTypeArchive(raw_path.as_ptr() as *const c_char, platform.handle) };
+            unsafe { BNCreateTypeArchive(raw_path.as_ptr(), platform.handle) };
         NonNull::new(handle).map(|handle| unsafe { TypeArchive::ref_from_raw(handle) })
     }
 
@@ -90,20 +90,15 @@ impl TypeArchive {
     ) -> Option<Ref<TypeArchive>> {
         let raw_path = path.as_ref().to_cstr();
         let id = id.to_cstr();
-        let handle = unsafe {
-            BNCreateTypeArchiveWithId(
-                raw_path.as_ptr() as *const c_char,
-                platform.handle,
-                id.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let handle =
+            unsafe { BNCreateTypeArchiveWithId(raw_path.as_ptr(), platform.handle, id.as_ptr()) };
         NonNull::new(handle).map(|handle| unsafe { TypeArchive::ref_from_raw(handle) })
     }
 
     /// Get a reference to the Type Archive with the known id, if one exists.
     pub fn lookup_by_id<S: AsCStr>(id: S) -> Option<Ref<TypeArchive>> {
         let id = id.to_cstr();
-        let handle = unsafe { BNLookupTypeArchiveById(id.as_ref().as_ptr() as *const c_char) };
+        let handle = unsafe { BNLookupTypeArchiveById(id.as_ptr()) };
         NonNull::new(handle).map(|handle| unsafe { TypeArchive::ref_from_raw(handle) })
     }
 
@@ -238,13 +233,8 @@ impl TypeArchive {
     pub fn rename_type_by_id<S: AsCStr>(&self, id: S, new_name: QualifiedName) -> bool {
         let id = id.to_cstr();
         let raw_name = QualifiedName::into_raw(new_name);
-        let result = unsafe {
-            BNRenameTypeArchiveType(
-                self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
-                &raw_name,
-            )
-        };
+        let result =
+            unsafe { BNRenameTypeArchiveType(self.handle.as_ptr(), id.as_ptr(), &raw_name) };
         QualifiedName::free_raw(raw_name);
         result
     }
@@ -261,9 +251,7 @@ impl TypeArchive {
     /// Delete an existing type in the type archive.
     pub fn delete_type_by_id<S: AsCStr>(&self, id: S) -> bool {
         let id = id.to_cstr();
-        let result = unsafe {
-            BNDeleteTypeArchiveType(self.handle.as_ptr(), id.as_ref().as_ptr() as *const c_char)
-        };
+        let result = unsafe { BNDeleteTypeArchiveType(self.handle.as_ptr(), id.as_ptr()) };
         result
     }
 
@@ -315,7 +303,7 @@ impl TypeArchive {
         let result = unsafe {
             BNGetTypeArchiveTypeById(
                 self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
+                id.as_ptr(),
                 snapshot.0.as_ptr() as *const c_char,
             )
         };
@@ -342,7 +330,7 @@ impl TypeArchive {
         let result = unsafe {
             BNGetTypeArchiveTypeName(
                 self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
+                id.as_ptr(),
                 snapshot.0.as_ptr() as *const c_char,
             )
         };
@@ -497,7 +485,7 @@ impl TypeArchive {
         let result = unsafe {
             BNGetTypeArchiveOutgoingDirectTypeReferences(
                 self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
+                id.as_ptr(),
                 snapshot.0.as_ptr() as *const c_char,
                 &mut count,
             )
@@ -527,7 +515,7 @@ impl TypeArchive {
         let result = unsafe {
             BNGetTypeArchiveOutgoingRecursiveTypeReferences(
                 self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
+                id.as_ptr(),
                 snapshot.0.as_ptr() as *const c_char,
                 &mut count,
             )
@@ -557,7 +545,7 @@ impl TypeArchive {
         let result = unsafe {
             BNGetTypeArchiveIncomingDirectTypeReferences(
                 self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
+                id.as_ptr(),
                 snapshot.0.as_ptr() as *const c_char,
                 &mut count,
             )
@@ -587,7 +575,7 @@ impl TypeArchive {
         let result = unsafe {
             BNGetTypeArchiveIncomingRecursiveTypeReferences(
                 self.handle.as_ptr(),
-                id.as_ref().as_ptr() as *const c_char,
+                id.as_ptr(),
                 snapshot.0.as_ptr() as *const c_char,
                 &mut count,
             )
@@ -599,9 +587,7 @@ impl TypeArchive {
     /// Look up a metadata entry in the archive
     pub fn query_metadata<S: AsCStr>(&self, key: S) -> Option<Ref<Metadata>> {
         let key = key.to_cstr();
-        let result = unsafe {
-            BNTypeArchiveQueryMetadata(self.handle.as_ptr(), key.as_ref().as_ptr() as *const c_char)
-        };
+        let result = unsafe { BNTypeArchiveQueryMetadata(self.handle.as_ptr(), key.as_ptr()) };
         (!result.is_null()).then(|| unsafe { Metadata::ref_from_raw(result) })
     }
 
@@ -611,25 +597,15 @@ impl TypeArchive {
     /// * `md` - object to store.
     pub fn store_metadata<S: AsCStr>(&self, key: S, md: &Metadata) {
         let key = key.to_cstr();
-        let result = unsafe {
-            BNTypeArchiveStoreMetadata(
-                self.handle.as_ptr(),
-                key.as_ref().as_ptr() as *const c_char,
-                md.handle,
-            )
-        };
+        let result =
+            unsafe { BNTypeArchiveStoreMetadata(self.handle.as_ptr(), key.as_ptr(), md.handle) };
         assert!(result);
     }
 
     /// Delete a given metadata entry in the archive from the `key`
     pub fn remove_metadata<S: AsCStr>(&self, key: S) -> bool {
         let key = key.to_cstr();
-        unsafe {
-            BNTypeArchiveRemoveMetadata(
-                self.handle.as_ptr(),
-                key.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNTypeArchiveRemoveMetadata(self.handle.as_ptr(), key.as_ptr()) }
     }
 
     /// Turn a given `snapshot` id into a data stream
@@ -708,7 +684,7 @@ impl TypeArchive {
     /// Determine if `file` is a Type Archive
     pub fn is_type_archive<P: AsCStr>(file: P) -> bool {
         let file = file.to_cstr();
-        unsafe { BNIsTypeArchive(file.as_ref().as_ptr() as *const c_char) }
+        unsafe { BNIsTypeArchive(file.as_ptr()) }
     }
 
     ///// Get the TypeContainer interface for this Type Archive, presenting types
@@ -840,9 +816,9 @@ impl TypeArchive {
         let success = unsafe {
             BNTypeArchiveMergeSnapshots(
                 self.handle.as_ptr(),
-                base_snapshot.as_ref().as_ptr() as *const c_char,
-                first_snapshot.as_ref().as_ptr() as *const c_char,
-                second_snapshot.as_ref().as_ptr() as *const c_char,
+                base_snapshot.as_ptr(),
+                first_snapshot.as_ptr(),
+                second_snapshot.as_ptr(),
                 merge_keys_raw,
                 merge_values_raw,
                 merge_keys.len(),
@@ -1169,12 +1145,7 @@ impl TypeArchiveMergeConflict {
     // TODO: This needs documentation!
     pub fn success<S: AsCStr>(&self, value: S) -> bool {
         let value = value.to_cstr();
-        unsafe {
-            BNTypeArchiveMergeConflictSuccess(
-                self.handle.as_ptr(),
-                value.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNTypeArchiveMergeConflictSuccess(self.handle.as_ptr(), value.as_ptr()) }
     }
 }
 
diff --git a/rust/src/type_container.rs b/rust/src/type_container.rs
index 5941b313..90b2ebc9 100644
--- a/rust/src/type_container.rs
+++ b/rust/src/type_container.rs
@@ -140,13 +140,8 @@ impl TypeContainer {
     pub fn rename_type<T: Into<QualifiedName>, S: AsCStr>(&self, name: T, type_id: S) -> bool {
         let type_id = type_id.to_cstr();
         let raw_name = QualifiedName::into_raw(name.into());
-        let success = unsafe {
-            BNTypeContainerRenameType(
-                self.handle.as_ptr(),
-                type_id.as_ref().as_ptr() as *const c_char,
-                &raw_name,
-            )
-        };
+        let success =
+            unsafe { BNTypeContainerRenameType(self.handle.as_ptr(), type_id.as_ptr(), &raw_name) };
         QualifiedName::free_raw(raw_name);
         success
     }
@@ -157,12 +152,7 @@ impl TypeContainer {
     /// Returns true if the type was deleted.
     pub fn delete_type<S: AsCStr>(&self, type_id: S) -> bool {
         let type_id = type_id.to_cstr();
-        unsafe {
-            BNTypeContainerDeleteType(
-                self.handle.as_ptr(),
-                type_id.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNTypeContainerDeleteType(self.handle.as_ptr(), type_id.as_ptr()) }
     }
 
     /// Get the unique id of the type in the Type Container with the given name.
@@ -184,11 +174,7 @@ impl TypeContainer {
         let type_id = type_id.to_cstr();
         let mut result = BNQualifiedName::default();
         let success = unsafe {
-            BNTypeContainerGetTypeName(
-                self.handle.as_ptr(),
-                type_id.as_ref().as_ptr() as *const c_char,
-                &mut result,
-            )
+            BNTypeContainerGetTypeName(self.handle.as_ptr(), type_id.as_ptr(), &mut result)
         };
         success.then(|| QualifiedName::from_owned_raw(result))
     }
@@ -200,11 +186,7 @@ impl TypeContainer {
         let type_id = type_id.to_cstr();
         let mut result = std::ptr::null_mut();
         let success = unsafe {
-            BNTypeContainerGetTypeById(
-                self.handle.as_ptr(),
-                type_id.as_ref().as_ptr() as *const c_char,
-                &mut result,
-            )
+            BNTypeContainerGetTypeById(self.handle.as_ptr(), type_id.as_ptr(), &mut result)
         };
         success.then(|| unsafe { Type::ref_from_raw(result) })
     }
@@ -313,7 +295,7 @@ impl TypeContainer {
         let success = unsafe {
             BNTypeContainerParseTypeString(
                 self.handle.as_ptr(),
-                source.as_ref().as_ptr() as *const c_char,
+                source.as_ptr(),
                 import_dependencies,
                 &mut result,
                 &mut errors,
@@ -358,18 +340,13 @@ impl TypeContainer {
         let source = source.to_cstr();
         let filename = filename.to_cstr();
         let options: Vec<_> = options.into_iter().map(|o| o.to_cstr()).collect();
-        let options_raw: Vec<*const c_char> = options
-            .iter()
-            .map(|o| o.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let options_raw: Vec<*const c_char> = options.iter().map(|o| o.as_ptr()).collect();
         let include_directories: Vec<_> = include_directories
             .into_iter()
             .map(|d| d.to_cstr())
             .collect();
-        let include_directories_raw: Vec<*const c_char> = include_directories
-            .iter()
-            .map(|d| d.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let include_directories_raw: Vec<*const c_char> =
+            include_directories.iter().map(|d| d.as_ptr()).collect();
         let auto_type_source = auto_type_source.to_cstr();
         let mut raw_result = BNTypeParserResult::default();
         let mut errors = std::ptr::null_mut();
@@ -377,13 +354,13 @@ impl TypeContainer {
         let success = unsafe {
             BNTypeContainerParseTypesFromSource(
                 self.handle.as_ptr(),
-                source.as_ref().as_ptr() as *const c_char,
-                filename.as_ref().as_ptr() as *const c_char,
+                source.as_ptr(),
+                filename.as_ptr(),
                 options_raw.as_ptr(),
                 options_raw.len(),
                 include_directories_raw.as_ptr(),
                 include_directories_raw.len(),
-                auto_type_source.as_ref().as_ptr() as *const c_char,
+                auto_type_source.as_ptr(),
                 import_dependencies,
                 &mut raw_result,
                 &mut errors,
diff --git a/rust/src/type_parser.rs b/rust/src/type_parser.rs
index 1cfe346c..af17a17f 100644
--- a/rust/src/type_parser.rs
+++ b/rust/src/type_parser.rs
@@ -29,9 +29,8 @@ pub fn register_type_parser<S: AsCStr, T: TypeParser>(
         freeResult: Some(cb_free_result),
         freeErrorList: Some(cb_free_error_list),
     };
-    let result = unsafe {
-        BNRegisterTypeParser(name.to_cstr().as_ref().as_ptr() as *const _, &mut callback)
-    };
+    let name = name.to_cstr();
+    let result = unsafe { BNRegisterTypeParser(name.as_ptr(), &mut callback) };
     let core = unsafe { CoreTypeParser::from_raw(NonNull::new(result).unwrap()) };
     (parser, core)
 }
@@ -54,7 +53,7 @@ impl CoreTypeParser {
 
     pub fn parser_by_name<S: AsCStr>(name: S) -> Option<CoreTypeParser> {
         let name_raw = name.to_cstr();
-        let result = unsafe { BNGetTypeParserByName(name_raw.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNGetTypeParserByName(name_raw.as_ptr()) };
         NonNull::new(result).map(|x| unsafe { Self::from_raw(x) })
     }
 
diff --git a/rust/src/type_printer.rs b/rust/src/type_printer.rs
index b49832de..278e486a 100644
--- a/rust/src/type_printer.rs
+++ b/rust/src/type_printer.rs
@@ -34,12 +34,8 @@ pub fn register_type_printer<S: AsCStr, T: TypePrinter>(
         freeString: Some(cb_free_string),
         freeLines: Some(cb_free_lines),
     };
-    let result = unsafe {
-        BNRegisterTypePrinter(
-            name.to_cstr().as_ref().as_ptr() as *const c_char,
-            &mut callback,
-        )
-    };
+    let raw_name = name.to_cstr();
+    let result = unsafe { BNRegisterTypePrinter(raw_name.as_ptr(), &mut callback) };
     let core = unsafe { CoreTypePrinter::from_raw(NonNull::new(result).unwrap()) };
     (parser, core)
 }
@@ -63,7 +59,7 @@ impl CoreTypePrinter {
 
     pub fn printer_by_name<S: AsCStr>(name: S) -> Option<CoreTypePrinter> {
         let name_raw = name.to_cstr();
-        let result = unsafe { BNGetTypePrinterByName(name_raw.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNGetTypePrinterByName(name_raw.as_ptr()) };
         NonNull::new(result).map(|x| unsafe { Self::from_raw(x) })
     }
 
diff --git a/rust/src/update.rs b/rust/src/update.rs
index aa8c7daf..b3c45d84 100644
--- a/rust/src/update.rs
+++ b/rust/src/update.rs
@@ -1,10 +1,10 @@
 #![allow(dead_code)]
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use crate::progress::{NoProgressCallback, ProgressCallback};
 use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner};
-use crate::string::{raw_to_string, BnString};
+use crate::string::{raw_to_string, AsCStr, BnString};
 use binaryninjacore_sys::*;
 
 pub type UpdateResult = BNUpdateResult;
@@ -96,8 +96,9 @@ impl UpdateChannel {
     pub fn versions(&self) -> Result<Array<UpdateVersion>, BnString> {
         let mut count = 0;
         let mut errors = std::ptr::null_mut();
+        let name = self.name.clone().to_cstr();
         let result = unsafe {
-            BNGetUpdateChannelVersions(self.name.as_ptr() as *const c_char, &mut count, &mut errors)
+            BNGetUpdateChannelVersions(name.as_ptr(), &mut count, &mut errors)
         };
         if !errors.is_null() {
             Err(unsafe { BnString::from_raw(errors) })
@@ -122,9 +123,10 @@ impl UpdateChannel {
     /// Whether updates are available
     pub fn updates_available(&self) -> Result<bool, BnString> {
         let mut errors = std::ptr::null_mut();
+        let name = self.name.clone().to_cstr();
         let result = unsafe {
             BNAreUpdatesAvailable(
-                self.name.as_ptr() as *const c_char,
+                name.as_ptr(),
                 std::ptr::null_mut(),
                 std::ptr::null_mut(),
                 &mut errors,
@@ -147,9 +149,10 @@ impl UpdateChannel {
     ) -> Result<UpdateResult, BnString> {
         let mut errors = std::ptr::null_mut();
 
+        let name = self.name.clone().to_cstr();
         let result = unsafe {
             BNUpdateToLatestVersion(
-                self.name.as_ptr() as *const c_char,
+                name.as_ptr(),
                 &mut errors,
                 Some(P::cb_progress_callback),
                 &mut progress as *mut P as *mut c_void,
@@ -174,10 +177,12 @@ impl UpdateChannel {
     ) -> Result<UpdateResult, BnString> {
         let mut errors = std::ptr::null_mut();
 
+        let name = self.name.clone().to_cstr();
+        let version = version.version.clone().to_cstr();
         let result = unsafe {
             BNUpdateToVersion(
-                self.name.as_ptr() as *const c_char,
-                version.version.as_ptr() as *const c_char,
+                name.as_ptr(),
+                version.as_ptr(),
                 &mut errors,
                 Some(P::cb_progress_callback),
                 &mut progress as *mut P as *mut c_void,
diff --git a/rust/src/websocket/client.rs b/rust/src/websocket/client.rs
index 43e1e1f7..e9e753b1 100644
--- a/rust/src/websocket/client.rs
+++ b/rust/src/websocket/client.rs
@@ -86,14 +86,8 @@ impl CoreWebsocketClient {
             .into_iter()
             .map(|(k, v)| (k.to_cstr(), v.to_cstr()))
             .unzip();
-        let header_keys: Vec<*const c_char> = header_keys
-            .iter()
-            .map(|k| k.as_ref().as_ptr() as *const c_char)
-            .collect();
-        let header_values: Vec<*const c_char> = header_values
-            .iter()
-            .map(|v| v.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let header_keys: Vec<*const c_char> = header_keys.iter().map(|k| k.as_ptr()).collect();
+        let header_values: Vec<*const c_char> = header_values.iter().map(|v| v.as_ptr()).collect();
         // SAFETY: This context will only be live for the duration of BNConnectWebsocketClient
         // SAFETY: Any subsequent call to BNConnectWebsocketClient will write over the context.
         let mut output_callbacks = BNWebsocketClientOutputCallbacks {
@@ -106,7 +100,7 @@ impl CoreWebsocketClient {
         unsafe {
             BNConnectWebsocketClient(
                 self.handle.as_ptr(),
-                url.as_ptr() as *const c_char,
+                url.as_ptr(),
                 header_keys.len().try_into().unwrap(),
                 header_keys.as_ptr(),
                 header_values.as_ptr(),
@@ -131,7 +125,7 @@ impl CoreWebsocketClient {
     pub fn notify_error(&self, msg: &str) {
         let error = msg.to_cstr();
         unsafe {
-            BNNotifyWebsocketClientError(self.handle.as_ptr(), error.as_ptr() as *const c_char)
+            BNNotifyWebsocketClientError(self.handle.as_ptr(), error.as_ptr())
         }
     }
 
diff --git a/rust/src/websocket/provider.rs b/rust/src/websocket/provider.rs
index 48c198d2..9cc1de84 100644
--- a/rust/src/websocket/provider.rs
+++ b/rust/src/websocket/provider.rs
@@ -3,7 +3,7 @@ use crate::string::{AsCStr, BnString};
 use crate::websocket::client;
 use crate::websocket::client::{CoreWebsocketClient, WebsocketClient};
 use binaryninjacore_sys::*;
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 use std::mem::MaybeUninit;
 use std::ptr::NonNull;
 
@@ -17,7 +17,7 @@ where
     let leaked_provider = Box::leak(Box::new(provider_uninit));
     let result = unsafe {
         BNRegisterWebsocketProvider(
-            name.as_ptr() as *const c_char,
+            name.as_ptr(),
             &mut BNWebsocketProviderCallbacks {
                 context: leaked_provider as *mut _ as *mut c_void,
                 createClient: Some(cb_create_client::<W>),
@@ -82,8 +82,7 @@ impl CoreWebsocketProvider {
 
     pub fn by_name<S: AsCStr>(name: S) -> Option<CoreWebsocketProvider> {
         let name = name.to_cstr();
-        let result =
-            unsafe { BNGetWebsocketProviderByName(name.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNGetWebsocketProviderByName(name.as_ptr()) };
         NonNull::new(result).map(|h| unsafe { Self::from_raw(h) })
     }
 
diff --git a/rust/src/worker_thread.rs b/rust/src/worker_thread.rs
index aed872de..e0d7b0db 100644
--- a/rust/src/worker_thread.rs
+++ b/rust/src/worker_thread.rs
@@ -1,6 +1,6 @@
 use crate::string::AsCStr;
 use binaryninjacore_sys::*;
-use std::ffi::{c_char, c_void};
+use std::ffi::c_void;
 
 pub struct WorkerThreadActionExecutor {
     func: Box<dyn Fn()>,
@@ -25,7 +25,7 @@ pub fn execute_on_worker_thread<F: Fn() + 'static, S: AsCStr>(name: S, f: F) {
         BNWorkerEnqueueNamed(
             raw_executor as *mut c_void,
             Some(WorkerThreadActionExecutor::cb_execute),
-            name.as_ref().as_ptr() as *const c_char,
+            name.as_ptr(),
         )
     }
 }
@@ -38,7 +38,7 @@ pub fn execute_on_worker_thread_priority<F: Fn() + 'static, S: AsCStr>(name: S,
         BNWorkerPriorityEnqueueNamed(
             raw_executor as *mut c_void,
             Some(WorkerThreadActionExecutor::cb_execute),
-            name.as_ref().as_ptr() as *const c_char,
+            name.as_ptr(),
         )
     }
 }
@@ -51,7 +51,7 @@ pub fn execute_on_worker_thread_interactive<F: Fn() + 'static, S: AsCStr>(name:
         BNWorkerInteractiveEnqueueNamed(
             raw_executor as *mut c_void,
             Some(WorkerThreadActionExecutor::cb_execute),
-            name.as_ref().as_ptr() as *const c_char,
+            name.as_ptr(),
         )
     }
 }
diff --git a/rust/src/workflow.rs b/rust/src/workflow.rs
index b5023815..9bbc0b31 100644
--- a/rust/src/workflow.rs
+++ b/rust/src/workflow.rs
@@ -110,12 +110,7 @@ impl AnalysisContext {
 
     pub fn inform<S: AsCStr>(&self, request: S) -> bool {
         let request = request.to_cstr();
-        unsafe {
-            BNAnalysisContextInform(
-                self.handle.as_ptr(),
-                request.as_ref().as_ptr() as *const c_char,
-            )
-        }
+        unsafe { BNAnalysisContextInform(self.handle.as_ptr(), request.as_ptr()) }
     }
 
     pub fn set_basic_blocks<I>(&self, blocks: I)
@@ -169,13 +164,8 @@ impl Activity {
     pub fn new<S: AsCStr>(config: S) -> Ref<Self> {
         unsafe extern "C" fn cb_action_nop(_: *mut c_void, _: *mut BNAnalysisContext) {}
         let config = config.to_cstr();
-        let result = unsafe {
-            BNCreateActivity(
-                config.as_ref().as_ptr() as *const c_char,
-                std::ptr::null_mut(),
-                Some(cb_action_nop),
-            )
-        };
+        let result =
+            unsafe { BNCreateActivity(config.as_ptr(), std::ptr::null_mut(), Some(cb_action_nop)) };
         unsafe { Activity::ref_from_raw(NonNull::new(result).unwrap()) }
     }
 
@@ -196,7 +186,7 @@ impl Activity {
         let config = config.to_cstr();
         let result = unsafe {
             BNCreateActivity(
-                config.as_ref().as_ptr() as *const c_char,
+                config.as_ptr(),
                 &mut action as *mut F as *mut c_void,
                 Some(cb_action::<F>),
             )
@@ -252,7 +242,7 @@ impl Workflow {
     /// To get a copy of an existing registered [Workflow] use [Workflow::clone_to].
     pub fn new<S: AsCStr>(name: S) -> Ref<Self> {
         let name = name.to_cstr();
-        let result = unsafe { BNCreateWorkflow(name.as_ref().as_ptr() as *const c_char) };
+        let result = unsafe { BNCreateWorkflow(name.as_ptr()) };
         unsafe { Workflow::ref_from_raw(NonNull::new(result).unwrap()) }
     }
 
@@ -280,8 +270,8 @@ impl Workflow {
             Self::ref_from_raw(
                 NonNull::new(BNWorkflowClone(
                     self.handle.as_ptr(),
-                    raw_name.as_ref().as_ptr() as *const c_char,
-                    activity.as_ref().as_ptr() as *const c_char,
+                    raw_name.as_ptr(),
+                    activity.as_ptr(),
                 ))
                 .unwrap(),
             )
@@ -289,8 +279,8 @@ impl Workflow {
     }
 
     pub fn instance<S: AsCStr>(name: S) -> Ref<Workflow> {
-        let result =
-            unsafe { BNWorkflowInstance(name.to_cstr().as_ref().as_ptr() as *const c_char) };
+        let name = name.to_cstr();
+        let result = unsafe { BNWorkflowInstance(name.as_ptr()) };
         unsafe { Workflow::ref_from_raw(NonNull::new(result).unwrap()) }
     }
 
@@ -318,12 +308,7 @@ impl Workflow {
     /// * `configuration` - a JSON representation of the workflow configuration
     pub fn register_with_config<S: AsCStr>(&self, config: S) -> Result<(), ()> {
         let config = config.to_cstr();
-        if unsafe {
-            BNRegisterWorkflow(
-                self.handle.as_ptr(),
-                config.as_ref().as_ptr() as *const c_char,
-            )
-        } {
+        if unsafe { BNRegisterWorkflow(self.handle.as_ptr(), config.as_ptr()) } {
             Ok(())
         } else {
             Err(())
@@ -351,10 +336,8 @@ impl Workflow {
         I::Item: AsCStr,
     {
         let subactivities_raw: Vec<_> = subactivities.into_iter().map(|x| x.to_cstr()).collect();
-        let mut subactivities_ptr: Vec<*const _> = subactivities_raw
-            .iter()
-            .map(|x| x.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut subactivities_ptr: Vec<*const _> =
+            subactivities_raw.iter().map(|x| x.as_ptr()).collect();
         let result = unsafe {
             BNWorkflowRegisterActivity(
                 self.handle.as_ptr(),
@@ -369,12 +352,8 @@ impl Workflow {
 
     /// Determine if an Activity exists in this [Workflow].
     pub fn contains<A: AsCStr>(&self, activity: A) -> bool {
-        unsafe {
-            BNWorkflowContains(
-                self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        }
+        let activity = activity.to_cstr();
+        unsafe { BNWorkflowContains(self.handle.as_ptr(), activity.as_ptr()) }
     }
 
     /// Retrieve the configuration as an adjacency list in JSON for the [Workflow].
@@ -387,12 +366,8 @@ impl Workflow {
     ///
     /// `activity` - return the configuration for the `activity`
     pub fn configuration_with_activity<A: AsCStr>(&self, activity: A) -> String {
-        let result = unsafe {
-            BNWorkflowGetConfiguration(
-                self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let activity = activity.to_cstr();
+        let result = unsafe { BNWorkflowGetConfiguration(self.handle.as_ptr(), activity.as_ptr()) };
         assert!(!result.is_null());
         unsafe { BnString::into_string(result) }
     }
@@ -409,12 +384,7 @@ impl Workflow {
     /// Retrieve the Activity object for the specified `name`.
     pub fn activity<A: AsCStr>(&self, name: A) -> Option<Ref<Activity>> {
         let name = name.to_cstr();
-        let result = unsafe {
-            BNWorkflowGetActivity(
-                self.handle.as_ptr(),
-                name.as_ref().as_ptr() as *const c_char,
-            )
-        };
+        let result = unsafe { BNWorkflowGetActivity(self.handle.as_ptr(), name.as_ptr()) };
         NonNull::new(result).map(|a| unsafe { Activity::ref_from_raw(a) })
     }
 
@@ -423,13 +393,10 @@ impl Workflow {
     ///
     /// * `activity` - if specified, return the roots for the `activity`
     pub fn activity_roots<A: AsCStr>(&self, activity: A) -> Array<BnString> {
+        let activity = activity.to_cstr();
         let mut count = 0;
         let result = unsafe {
-            BNWorkflowGetActivityRoots(
-                self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
-                &mut count,
-            )
+            BNWorkflowGetActivityRoots(self.handle.as_ptr(), activity.as_ptr(), &mut count)
         };
         assert!(!result.is_null());
         unsafe { Array::new(result as *mut *mut c_char, count, ()) }
@@ -440,11 +407,12 @@ impl Workflow {
     /// * `activity` - if specified, return the direct children and optionally the descendants of the `activity` (includes `activity`)
     /// * `immediate` - whether to include only direct children of `activity` or all descendants
     pub fn subactivities<A: AsCStr>(&self, activity: A, immediate: bool) -> Array<BnString> {
+        let activity = activity.to_cstr();
         let mut count = 0;
         let result = unsafe {
             BNWorkflowGetSubactivities(
                 self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
+                activity.as_ptr(),
                 immediate,
                 &mut count,
             )
@@ -463,15 +431,13 @@ impl Workflow {
         I: IntoIterator,
         I::Item: AsCStr,
     {
+        let activity = activity.to_cstr();
         let input_list: Vec<_> = activities.into_iter().map(|a| a.to_cstr()).collect();
-        let mut input_list_ptr: Vec<*const _> = input_list
-            .iter()
-            .map(|x| x.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut input_list_ptr: Vec<*const _> = input_list.iter().map(|x| x.as_ptr()).collect();
         unsafe {
             BNWorkflowAssignSubactivities(
                 self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
+                activity.as_ptr(),
                 input_list_ptr.as_mut_ptr(),
                 input_list.len(),
             )
@@ -493,15 +459,13 @@ impl Workflow {
         I: IntoIterator,
         I::Item: AsCStr,
     {
+        let activity = activity.to_cstr();
         let input_list: Vec<_> = activities.into_iter().map(|a| a.to_cstr()).collect();
-        let mut input_list_ptr: Vec<*const _> = input_list
-            .iter()
-            .map(|x| x.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut input_list_ptr: Vec<*const _> = input_list.iter().map(|x| x.as_ptr()).collect();
         unsafe {
             BNWorkflowInsert(
                 self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
+                activity.as_ptr(),
                 input_list_ptr.as_mut_ptr(),
                 input_list.len(),
             )
@@ -518,15 +482,13 @@ impl Workflow {
         I: IntoIterator,
         I::Item: AsCStr,
     {
+        let activity = activity.to_cstr();
         let input_list: Vec<_> = activities.into_iter().map(|a| a.to_cstr()).collect();
-        let mut input_list_ptr: Vec<*const _> = input_list
-            .iter()
-            .map(|x| x.as_ref().as_ptr() as *const c_char)
-            .collect();
+        let mut input_list_ptr: Vec<*const _> = input_list.iter().map(|x| x.as_ptr()).collect();
         unsafe {
             BNWorkflowInsertAfter(
                 self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
+                activity.as_ptr(),
                 input_list_ptr.as_mut_ptr(),
                 input_list.len(),
             )
@@ -535,12 +497,8 @@ impl Workflow {
 
     /// Remove the specified `activity`
     pub fn remove<A: AsCStr>(&self, activity: A) -> bool {
-        unsafe {
-            BNWorkflowRemove(
-                self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
-            )
-        }
+        let activity = activity.to_cstr();
+        unsafe { BNWorkflowRemove(self.handle.as_ptr(), activity.as_ptr()) }
     }
 
     /// Replace the specified `activity`.
@@ -548,11 +506,13 @@ impl Workflow {
     /// * `activity` - the Activity to replace
     /// * `new_activity` - the replacement Activity
     pub fn replace<A: AsCStr, N: AsCStr>(&self, activity: A, new_activity: N) -> bool {
+        let activity = activity.to_cstr();
+        let new_activity = new_activity.to_cstr();
         unsafe {
             BNWorkflowReplace(
                 self.handle.as_ptr(),
-                activity.to_cstr().as_ref().as_ptr() as *const c_char,
-                new_activity.to_cstr().as_ref().as_ptr() as *const c_char,
+                activity.as_ptr(),
+                new_activity.as_ptr(),
             )
         }
     }
@@ -567,14 +527,9 @@ impl Workflow {
         sequential: Option<bool>,
     ) -> Option<Ref<FlowGraph>> {
         let sequential = sequential.unwrap_or(false);
-        let activity_name = activity.to_cstr();
-        let graph = unsafe {
-            BNWorkflowGetGraph(
-                self.handle.as_ptr(),
-                activity_name.as_ref().as_ptr() as *const c_char,
-                sequential,
-            )
-        };
+        let activity = activity.to_cstr();
+        let graph =
+            unsafe { BNWorkflowGetGraph(self.handle.as_ptr(), activity.as_ptr(), sequential) };
         if graph.is_null() {
             return None;
         }