More useless enum deletion.

src/transform/delete_enums_with_variants.rs

@@ -0,0 +1,45 @@
+use log::*;
+use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet};
+
+use super::delete_enums::remove_enum_ids;
+use crate::ir::*;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DeleteEnumsWithVariants {
+    variants: HashMap<u64, String>,
+    #[serde(default)]
+    pub soft: bool,
+}
+
+impl DeleteEnumsWithVariants {
+    pub fn run(&self, ir: &mut IR) -> anyhow::Result<()> {
+        let mut ids: HashSet<String> = HashSet::new();
+
+        'e: for (id, e) in &ir.enums {
+            if e.variants.len() != self.variants.len() {
+                continue;
+            }
+            for v in &e.variants {
+                let Some(name) = self.variants.get(&v.value) else {
+                    continue 'e;
+                };
+                if name != &v.name {
+                    continue 'e;
+                }
+            }
+            info!("deleting enum {}", id);
+            ids.insert(id.clone());
+        }
+
+        remove_enum_ids(ir, &ids);
+
+        if !self.soft {
+            for id in ids {
+                ir.enums.remove(&id);
+            }
+        }
+
+        Ok(())
+    }
+}

src/transform/delete_useless_enums.rs

@@ -46,6 +46,8 @@ const USELESS_ZERO_NAMES: &[&str] = &[
     "discon",
     "disconnect",
     "disconnected",
+    "not_detected",
+    "invalid",
 ];
 const USELESS_ONE_NAMES: &[&str] = &[
     "en",
@@ -58,9 +60,11 @@ const USELESS_ONE_NAMES: &[&str] = &[
     "available",
     "connect",
     "connected",
+    "detected",
+    "valid",
 ];
 
-const NOT_NAMES: &[&str] = &["not", "no"];
+const NOT_NAMES: &[&str] = &["not", "no", "un", "de", "in"];
 
 fn is_useless(e: &Enum) -> bool {
     match e.bit_size {
@@ -76,9 +80,10 @@ fn is_useless(e: &Enum) -> bool {
 
                 let obvious = USELESS_ZERO_NAMES.iter().any(|s| s == &zero_name)
                     && USELESS_ONE_NAMES.iter().any(|s| s == &one_name);
-                let not = NOT_NAMES
-                    .iter()
-                    .any(|not| zero_name == format!("{not}{one_name}"));
+                let not = NOT_NAMES.iter().any(|not| {
+                    zero_name == format!("{not}{one_name}")
+                        || zero_name == format!("{not}_{one_name}")
+                });
 
                 obvious || not
             }

src/transform/mod.rs

@@ -253,11 +253,10 @@ mod common;
 pub mod delete;
 pub mod delete_enums;
 pub mod delete_enums_used_in;
+pub mod delete_enums_with_variants;
 pub mod delete_fieldsets;
-pub mod delete_useless_enums;
-//pub mod find_duplicate_enums;
-//pub mod find_duplicate_fieldsets;
 pub mod delete_registers;
+pub mod delete_useless_enums;
 pub mod expand_extends;
 pub mod fix_register_bit_sizes;
 pub mod make_block;
@@ -279,6 +278,7 @@ pub enum Transform {
     Sort(sort::Sort),
     Delete(delete::Delete),
     DeleteEnums(delete_enums::DeleteEnums),
+    DeleteEnumsWithVariants(delete_enums_with_variants::DeleteEnumsWithVariants),
     DeleteEnumsUsedIn(delete_enums_used_in::DeleteEnumsUsedIn),
     DeleteUselessEnums(delete_useless_enums::DeleteUselessEnums),
     DeleteFieldsets(delete_fieldsets::DeleteFieldsets),
@@ -307,6 +307,7 @@ impl Transform {
             Self::Delete(t) => t.run(ir),
             Self::DeleteEnums(t) => t.run(ir),
             Self::DeleteEnumsUsedIn(t) => t.run(ir),
+            Self::DeleteEnumsWithVariants(t) => t.run(ir),
             Self::DeleteUselessEnums(t) => t.run(ir),
             Self::DeleteFieldsets(t) => t.run(ir),
             Self::DeleteRegisters(t) => t.run(ir),