Fix incorrect immutable borrow for EnumerationBuilder

plugins/dwarf/dwarf_import/src/die_handlers.rs

@@ -104,7 +104,7 @@ pub(crate) fn handle_enum<R: ReaderType>(
     //  DW_AT_const_value
     //  *DW_AT_description
 
-    let enumeration_builder = EnumerationBuilder::new();
+    let mut enumeration_builder = EnumerationBuilder::new();
 
     let mut tree = unit.entries_tree(Some(entry.offset())).unwrap();
     let mut children = tree.root().unwrap().children();

plugins/idb_import/src/types.rs

@@ -462,7 +462,7 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
     }
 
     fn translate_enum(members: &[(Option<Vec<u8>>, u64)], bytesize: u64) -> Ref<Type> {
-        let eb = EnumerationBuilder::new();
+        let mut eb = EnumerationBuilder::new();
         for (i, (name, bytesize)) in members.iter().enumerate() {
             let name = name
                 .as_ref()

plugins/pdb-ng/src/type_parser.rs

@@ -1626,7 +1626,7 @@ impl<'a, S: Source<'a> + 'a> PDBParserInstance<'a, S> {
             )))));
         }
 
-        let enumeration = EnumerationBuilder::new();
+        let mut enumeration = EnumerationBuilder::new();
 
         match self.handle_type_index(data.fields, finder)? {
             Some(ParsedType::FieldList(fields)) => {

plugins/warp/src/convert.rs

@@ -470,7 +470,7 @@ pub fn to_bn_type<A: BNArchitecture>(arch: &A, ty: &Type) -> BNRef<BNType> {
             BNType::structure(&builder.finalize())
         }
         TypeClass::Enumeration(c) => {
-            let builder = BNEnumerationBuilder::new();
+            let mut builder = BNEnumerationBuilder::new();
             for member in &c.members {
                 // TODO: Add default name?
                 let member_name = member.name.to_owned().unwrap_or("enum_VAL".into());

rust/src/types.rs

@@ -1217,31 +1217,31 @@ impl EnumerationBuilder {
         unsafe { Enumeration::ref_from_raw(BNFinalizeEnumerationBuilder(self.handle)) }
     }
 
-    pub fn append<S: BnStrCompatible>(&self, name: S) -> &Self {
+    pub fn append<S: BnStrCompatible>(&mut self, name: S) -> &Self {
         let name = name.into_bytes_with_nul();
         unsafe {
             BNAddEnumerationBuilderMember(self.handle, name.as_ref().as_ptr() as _);
         }
         self
     }
 
-    pub fn insert<S: BnStrCompatible>(&self, name: S, value: u64) -> &Self {
+    pub fn insert<S: BnStrCompatible>(&mut self, name: S, value: u64) -> &Self {
         let name = name.into_bytes_with_nul();
         unsafe {
             BNAddEnumerationBuilderMemberWithValue(self.handle, name.as_ref().as_ptr() as _, value);
         }
         self
     }
 
-    pub fn replace<S: BnStrCompatible>(&self, id: usize, name: S, value: u64) -> &Self {
+    pub fn replace<S: BnStrCompatible>(&mut self, id: usize, name: S, value: u64) -> &Self {
         let name = name.into_bytes_with_nul();
         unsafe {
             BNReplaceEnumerationBuilderMember(self.handle, id, name.as_ref().as_ptr() as _, value);
         }
         self
     }
 
-    pub fn remove(&self, id: usize) -> &Self {
+    pub fn remove(&mut self, id: usize) -> &Self {
         unsafe {
             BNRemoveEnumerationBuilderMember(self.handle, id);
         }