Clean up iters

src/commands/fmt.rs

@@ -27,8 +27,8 @@ pub fn fmt(args: Fmt) -> Result<()> {
         if args.remove_unused {
             let mut used_enums = BTreeSet::new();
             for fs in ir.fieldsets.values_mut() {
-                for f in fs.fields.iter_mut().filter(|f| f.enumm.is_some()) {
-                    used_enums.insert(f.enumm.as_ref().unwrap().clone());
+                for enumm in fs.fields.iter_mut().filter_map(|f| f.enumm.as_ref()) {
+                    used_enums.insert(enumm.clone());
                 }
             }
 

src/generate/mod.rs

@@ -237,11 +237,7 @@ fn process_array(array: &Array) -> (usize, TokenStream) {
         }
         Array::Cursed(array) => {
             let len = array.offsets.len();
-            let offsets = array
-                .offsets
-                .iter()
-                .map(|&x| x as usize)
-                .collect::<Vec<_>>();
+            let offsets = array.offsets.iter().map(|&x| x as usize);
             let offs_expr = quote!(([#(#offsets),*][n] as usize));
             (len, offs_expr)
         }

src/transform/merge_enums.rs

@@ -1,4 +1,4 @@
-use anyhow::bail;
+use anyhow::{bail, Context};
 use log::*;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeSet;
@@ -58,12 +58,15 @@ impl MergeEnums {
 
         for id in &ids {
             let e2 = ir.enums.get(id).unwrap();
-            if let Err(e) = check_mergeable_enums(&main_id, &e, id, e2, self.check) {
+            if let Err(e) = check_mergeable_enums(&e, e2, self.check) {
                 if self.skip_unmergeable {
                     info!("skipping: {:?}", to);
                     return Ok(());
                 } else {
-                    return Err(e);
+                    return Err(e).context(format!(
+                        "Failed to merge enums.\nfirst: {}\n{:#?}\nsecond: {}\n{:#?}",
+                        main_id, main, id, e2,
+                    ));
                 }
             }
         }
@@ -78,20 +81,7 @@ impl MergeEnums {
     }
 }
 
-fn check_mergeable_enums(
-    a_id: &str,
-    a: &Enum,
-    b_id: &str,
-    b: &Enum,
-    level: CheckLevel,
-) -> anyhow::Result<()> {
-    if let Err(e) = check_mergeable_enums_inner(a, b, level) {
-        bail!("Cannot merge enums.\nfirst: {a_id}\n{a:#?}\nsecond: {b_id}\n{b:#?}\ncause: {e:?}",)
-    }
-    Ok(())
-}
-
-fn check_mergeable_enums_inner(a: &Enum, b: &Enum, level: CheckLevel) -> anyhow::Result<()> {
+fn check_mergeable_enums(a: &Enum, b: &Enum, level: CheckLevel) -> anyhow::Result<()> {
     if a.bit_size != b.bit_size {
         bail!("Different bit size: {} vs {}", a.bit_size, b.bit_size)
     }

src/transform/resize_enums.rs

@@ -70,17 +70,12 @@ fn verify_variants(ir: &IR, enumm: &str) -> anyhow::Result<()> {
 fn update_uses(ir: &mut IR, enumm: &str) -> anyhow::Result<()> {
     let fieldsets = ir
         .fieldsets
-        .iter()
-        .filter(|(_, fs)| fs.fields.iter().any(|f| f.enumm.as_deref() == Some(enumm)))
-        .map(|(name, _)| name)
-        .cloned()
-        .collect::<Vec<_>>();
+        .iter_mut()
+        .filter(|(_, fs)| fs.fields.iter().any(|f| f.enumm.as_deref() == Some(enumm)));
 
     let bit_size = ir.enums.get(enumm).unwrap().bit_size;
 
-    for fs_name in fieldsets {
-        let fs = ir.fieldsets.get_mut(&fs_name).unwrap();
-
+    for (fs_name, fs) in fieldsets {
         for field in fs
             .fields
             .iter_mut()