Misc cleanup in Rust API

Author: emesare

rust/src/function.rs

@@ -485,12 +485,7 @@ impl Function {
         language: &str,
     ) -> Option<Ref<CoreLanguageRepresentationFunction>> {
         let lang_name = language.to_cstr();
-        let repr = unsafe {
-            BNGetFunctionLanguageRepresentation(
-                self.handle,
-                lang_name.as_ptr(),
-            )
-        };
+        let repr = unsafe { BNGetFunctionLanguageRepresentation(self.handle, lang_name.as_ptr()) };
         NonNull::new(repr)
             .map(|handle| unsafe { CoreLanguageRepresentationFunction::ref_from_raw(handle) })
     }
@@ -504,10 +499,7 @@ impl Function {
     ) -> Option<Ref<CoreLanguageRepresentationFunction>> {
         let lang_name = language.to_cstr();
         let repr = unsafe {
-            BNGetFunctionLanguageRepresentationIfAvailable(
-                self.handle,
-                lang_name.as_ptr(),
-            )
+            BNGetFunctionLanguageRepresentationIfAvailable(self.handle, lang_name.as_ptr())
         };
         NonNull::new(repr)
             .map(|handle| unsafe { CoreLanguageRepresentationFunction::ref_from_raw(handle) })

rust/src/string.rs

@@ -14,9 +14,7 @@
 
 //! String wrappers for core-owned strings and strings being passed to the core
 
-use crate::rc::*;
-use crate::type_archive::TypeArchiveSnapshotId;
-use crate::types::QualifiedName;
+use binaryninjacore_sys::*;
 use std::borrow::Cow;
 use std::ffi::{c_char, CStr, CString};
 use std::fmt;
@@ -25,6 +23,10 @@ use std::mem;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
+use crate::rc::*;
+use crate::type_archive::TypeArchiveSnapshotId;
+use crate::types::QualifiedName;
+
 // TODO: Remove or refactor this.
 pub(crate) fn raw_to_string(ptr: *const c_char) -> Option<String> {
     if ptr.is_null() {
@@ -66,8 +68,7 @@ pub struct BnString {
 }
 
 impl BnString {
-    pub fn new<S: IntoCStr>(s: S) -> Self {
-        use binaryninjacore_sys::BNAllocString;
+    pub fn new(s: impl IntoCStr) -> Self {
         let raw = s.to_cstr();
         unsafe { Self::from_raw(BNAllocString(raw.as_ptr())) }
     }
@@ -79,14 +80,13 @@ impl BnString {
         Self::from_raw(raw).to_string_lossy().to_string()
     }
 
-    /// Construct a BnString from an owned const char* allocated by BNAllocString
+    /// Construct a BnString from an owned const char* allocated by [`BNAllocString`].
     pub(crate) unsafe fn from_raw(raw: *mut c_char) -> Self {
         Self { raw }
     }
 
-    /// Free a raw string allocated by BNAllocString.
+    /// Free a raw string allocated by [`BNAllocString`].
     pub(crate) unsafe fn free_raw(raw: *mut c_char) {
-        use binaryninjacore_sys::BNFreeString;
         if !raw.is_null() {
             BNFreeString(raw);
         }
@@ -115,7 +115,6 @@ impl Drop for BnString {
 
 impl Clone for BnString {
     fn clone(&self) -> Self {
-        use binaryninjacore_sys::BNAllocString;
         unsafe {
             Self {
                 raw: BNAllocString(self.raw),
@@ -178,7 +177,6 @@ impl CoreArrayProvider for BnString {
 
 unsafe impl CoreArrayProviderInner for BnString {
     unsafe fn free(raw: *mut Self::Raw, count: usize, _context: &Self::Context) {
-        use binaryninjacore_sys::BNFreeStringList;
         BNFreeStringList(raw, count);
     }
 
@@ -187,101 +185,101 @@ unsafe impl CoreArrayProviderInner for BnString {
     }
 }
 
-pub unsafe trait IntoCStr {
+pub trait IntoCStr {
     type Result: Deref<Target = CStr>;
 
     fn to_cstr(self) -> Self::Result;
 }
 
-unsafe impl IntoCStr for &CStr {
+impl IntoCStr for &CStr {
     type Result = Self;
 
     fn to_cstr(self) -> Self::Result {
         self
     }
 }
 
-unsafe impl IntoCStr for BnString {
+impl IntoCStr for BnString {
     type Result = Self;
 
     fn to_cstr(self) -> Self::Result {
         self
     }
 }
 
-unsafe impl IntoCStr for &BnString {
+impl IntoCStr for &BnString {
     type Result = BnString;
 
     fn to_cstr(self) -> Self::Result {
         self.clone()
     }
 }
 
-unsafe impl IntoCStr for CString {
+impl IntoCStr for CString {
     type Result = Self;
 
     fn to_cstr(self) -> Self::Result {
         self
     }
 }
 
-unsafe impl IntoCStr for &str {
+impl IntoCStr for &str {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         CString::new(self).expect("can't pass strings with internal nul bytes to core!")
     }
 }
 
-unsafe impl IntoCStr for String {
+impl IntoCStr for String {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         CString::new(self).expect("can't pass strings with internal nul bytes to core!")
     }
 }
 
-unsafe impl IntoCStr for &String {
+impl IntoCStr for &String {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         self.clone().to_cstr()
     }
 }
 
-unsafe impl<'a> IntoCStr for &'a Cow<'a, str> {
+impl<'a> IntoCStr for &'a Cow<'a, str> {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         self.to_string().to_cstr()
     }
 }
 
-unsafe impl IntoCStr for Cow<'_, str> {
+impl IntoCStr for Cow<'_, str> {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         self.to_string().to_cstr()
     }
 }
 
-unsafe impl IntoCStr for &QualifiedName {
+impl IntoCStr for &QualifiedName {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         self.to_string().to_cstr()
     }
 }
 
-unsafe impl IntoCStr for PathBuf {
+impl IntoCStr for PathBuf {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
         self.as_path().to_cstr()
     }
 }
 
-unsafe impl IntoCStr for &Path {
+impl IntoCStr for &Path {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {
@@ -290,7 +288,7 @@ unsafe impl IntoCStr for &Path {
     }
 }
 
-unsafe impl IntoCStr for TypeArchiveSnapshotId {
+impl IntoCStr for TypeArchiveSnapshotId {
     type Result = CString;
 
     fn to_cstr(self) -> Self::Result {

rust/tests/line_formatter.rs

@@ -20,5 +20,6 @@ fn test_custom_line_formatter() {
     let _session = Session::new().expect("Failed to initialize session");
     let out_dir = env!("OUT_DIR").parse::<PathBuf>().unwrap();
     let line_formatter = register_line_formatter("my_line_formatter", MyLineFormatter {});
-    assert_eq!(line_formatter.name().as_str(), "my_line_formatter");
+    assert_eq!(line_formatter.name(), "my_line_formatter".into());
+    // TODO: Finish this test.
 }