1 files changed, 23 insertions, 34 deletions

diff --git a/rust/src/debuginfo.rs b/rust/src/debuginfo.rs
index 248726f3..a4d0b139 100644
--- a/rust/src/debuginfo.rs
+++ b/rust/src/debuginfo.rs
@@ -115,7 +115,7 @@ impl DebugInfoParser {
     }
 
     /// Returns debug info parser of the given name, if it exists
-    pub fn from_name<S: IntoCStr>(name: S) -> Result<Ref<Self>, ()> {
+    pub fn from_name(name: &str) -> Result<Ref<Self>, ()> {
         let name = name.to_cstr();
         let parser = unsafe { BNGetDebugInfoParserByName(name.as_ptr()) };
 
@@ -207,9 +207,8 @@ impl DebugInfoParser {
     }
 
     // Registers a DebugInfoParser. See `binaryninja::debuginfo::DebugInfoParser` for more details.
-    pub fn register<S, C>(name: S, parser_callbacks: C) -> Ref<Self>
+    pub fn register<C>(name: &str, parser_callbacks: C) -> Ref<Self>
     where
-        S: IntoCStr,
         C: CustomDebugInfoParser,
     {
         extern "C" fn cb_is_valid<C>(ctxt: *mut c_void, view: *mut BNBinaryView) -> bool
@@ -418,7 +417,7 @@ impl DebugInfo {
     }
 
     /// Returns all types within the parser
-    pub fn types_by_name<S: IntoCStr>(&self, parser_name: S) -> Vec<NameAndType> {
+    pub fn types_by_name(&self, parser_name: &str) -> Vec<NameAndType> {
         let parser_name = parser_name.to_cstr();
 
         let mut count: usize = 0;
@@ -451,7 +450,7 @@ impl DebugInfo {
     }
 
     /// Returns all functions within the parser
-    pub fn functions_by_name<S: IntoCStr>(&self, parser_name: S) -> Vec<DebugFunctionInfo> {
+    pub fn functions_by_name(&self, parser_name: &str) -> Vec<DebugFunctionInfo> {
         let parser_name = parser_name.to_cstr();
 
         let mut count: usize = 0;
@@ -486,10 +485,7 @@ impl DebugInfo {
     }
 
     /// Returns all data variables within the parser
-    pub fn data_variables_by_name<S: IntoCStr>(
-        &self,
-        parser_name: S,
-    ) -> Vec<NamedDataVariableWithType> {
+    pub fn data_variables_by_name(&self, parser_name: &str) -> Vec<NamedDataVariableWithType> {
         let parser_name = parser_name.to_cstr();
 
         let mut count: usize = 0;
@@ -523,7 +519,7 @@ impl DebugInfo {
         result
     }
 
-    pub fn type_by_name<S: IntoCStr>(&self, parser_name: S, name: S) -> Option<Ref<Type>> {
+    pub fn type_by_name(&self, parser_name: &str, name: &str) -> Option<Ref<Type>> {
         let parser_name = parser_name.to_cstr();
         let name = name.to_cstr();
 
@@ -536,10 +532,10 @@ impl DebugInfo {
         }
     }
 
-    pub fn get_data_variable_by_name<S: IntoCStr>(
+    pub fn get_data_variable_by_name(
         &self,
-        parser_name: S,
-        name: S,
+        parser_name: &str,
+        name: &str,
     ) -> Option<NamedDataVariableWithType> {
         let parser_name = parser_name.to_cstr();
         let name = name.to_cstr();
@@ -558,9 +554,9 @@ impl DebugInfo {
         }
     }
 
-    pub fn get_data_variable_by_address<S: IntoCStr>(
+    pub fn get_data_variable_by_address(
         &self,
-        parser_name: S,
+        parser_name: &str,
         address: u64,
     ) -> Option<NamedDataVariableWithType> {
         let parser_name = parser_name.to_cstr();
@@ -576,7 +572,7 @@ impl DebugInfo {
     }
 
     /// Returns a list of [`NameAndType`] where the `name` is the parser the type originates from.
-    pub fn get_types_by_name<S: IntoCStr>(&self, name: S) -> Vec<NameAndType> {
+    pub fn get_types_by_name(&self, name: &str) -> Vec<NameAndType> {
         let mut count: usize = 0;
         let name = name.to_cstr();
         let raw_names_and_types_ptr =
@@ -595,10 +591,7 @@ impl DebugInfo {
     }
 
     // The tuple is (DebugInfoParserName, address, type)
-    pub fn get_data_variables_by_name<S: IntoCStr>(
-        &self,
-        name: S,
-    ) -> Vec<(String, u64, Ref<Type>)> {
+    pub fn get_data_variables_by_name(&self, name: &str) -> Vec<(String, u64, Ref<Type>)> {
         let name = name.to_cstr();
 
         let mut count: usize = 0;
@@ -649,55 +642,51 @@ impl DebugInfo {
         result
     }
 
-    pub fn remove_parser_info<S: IntoCStr>(&self, parser_name: S) -> bool {
+    pub fn remove_parser_info(&self, parser_name: &str) -> bool {
         let parser_name = parser_name.to_cstr();
 
         unsafe { BNRemoveDebugParserInfo(self.handle, parser_name.as_ptr()) }
     }
 
-    pub fn remove_parser_types<S: IntoCStr>(&self, parser_name: S) -> bool {
+    pub fn remove_parser_types(&self, parser_name: &str) -> bool {
         let parser_name = parser_name.to_cstr();
 
         unsafe { BNRemoveDebugParserTypes(self.handle, parser_name.as_ptr()) }
     }
 
-    pub fn remove_parser_functions<S: IntoCStr>(&self, parser_name: S) -> bool {
+    pub fn remove_parser_functions(&self, parser_name: &str) -> bool {
         let parser_name = parser_name.to_cstr();
 
         unsafe { BNRemoveDebugParserFunctions(self.handle, parser_name.as_ptr()) }
     }
 
-    pub fn remove_parser_data_variables<S: IntoCStr>(&self, parser_name: S) -> bool {
+    pub fn remove_parser_data_variables(&self, parser_name: &str) -> bool {
         let parser_name = parser_name.to_cstr();
 
         unsafe { BNRemoveDebugParserDataVariables(self.handle, parser_name.as_ptr()) }
     }
 
-    pub fn remove_type_by_name<S: IntoCStr>(&self, parser_name: S, name: S) -> bool {
+    pub fn remove_type_by_name(&self, parser_name: &str, name: &str) -> bool {
         let parser_name = parser_name.to_cstr();
         let name = name.to_cstr();
 
         unsafe { BNRemoveDebugTypeByName(self.handle, parser_name.as_ptr(), name.as_ptr()) }
     }
 
-    pub fn remove_function_by_index<S: IntoCStr>(&self, parser_name: S, index: usize) -> bool {
+    pub fn remove_function_by_index(&self, parser_name: &str, index: usize) -> bool {
         let parser_name = parser_name.to_cstr();
 
         unsafe { BNRemoveDebugFunctionByIndex(self.handle, parser_name.as_ptr(), index) }
     }
 
-    pub fn remove_data_variable_by_address<S: IntoCStr>(
-        &self,
-        parser_name: S,
-        address: u64,
-    ) -> bool {
+    pub fn remove_data_variable_by_address(&self, parser_name: &str, address: u64) -> bool {
         let parser_name = parser_name.to_cstr();
 
         unsafe { BNRemoveDebugDataVariableByAddress(self.handle, parser_name.as_ptr(), address) }
     }
 
     /// Adds a type scoped under the current parser's name to the debug info
-    pub fn add_type<S: IntoCStr>(&self, name: S, new_type: &Type, components: &[&str]) -> bool {
+    pub fn add_type(&self, name: &str, new_type: &Type, components: &[&str]) -> bool {
         // SAFETY: Lifetime of `components` will live long enough, so passing as_ptr is safe.
         let raw_components: Vec<_> = components.iter().map(|&c| c.as_ptr()).collect();
 
@@ -779,11 +768,11 @@ impl DebugInfo {
     }
 
     /// Adds a data variable scoped under the current parser's name to the debug info
-    pub fn add_data_variable<S: IntoCStr>(
+    pub fn add_data_variable(
         &self,
         address: u64,
         t: &Type,
-        name: Option<S>,
+        name: Option<&str>,
         components: &[&str],
     ) -> bool {
         let mut components_array: Vec<*const ::std::os::raw::c_char> =