unused

crates/libs/bindgen/src/error.rs

@@ -44,12 +44,4 @@ impl Error {
     pub(crate) fn with_path(self, path: &str) -> Self {
         Self { path: path.to_string(), ..self }
     }
-
-    // pub(crate) fn with_span(self, span: proc_macro2::Span) -> Self {
-    //     let start = span.start();
-    //     Self {
-    //         span: Some((start.line, start.column)),
-    //         ..self
-    //     }
-    // }
 }

crates/libs/bindgen/src/winmd/verify.rs

@@ -2,6 +2,18 @@ use super::*;
 use metadata::RowReader;
 
 pub fn verify(reader: &metadata::Reader, filter: &metadata::Filter) -> crate::Result<()> {
+    let unused: Vec<&str> = filter.unused(reader).collect();
+
+    if !unused.is_empty() {
+        let mut message = "unused filters".to_string();
+
+        for unused in unused {
+            message.push_str(&format!("\n  {unused}"));
+        }
+
+        return Err(crate::Error::new(&message));
+    }
+
     for item in reader.items(filter) {
         // TODO: cover all variants
         let metadata::Item::Type(def) = item else {

crates/libs/metadata/src/filter.rs

@@ -70,6 +70,10 @@ impl<'a> Filter<'a> {
     fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
+
+    pub fn unused(&self, reader: &'a Reader) -> impl Iterator<Item = &str> + '_ {
+        self.0.iter().filter_map(|(name, _)| if reader.unused(name) { Some(*name) } else { None })
+    }
 }
 
 fn match_type_name(rule: &str, namespace: &str, name: &str) -> bool {

crates/libs/metadata/src/lib.rs

@@ -130,6 +130,29 @@ impl<'a> Reader<'a> {
         self.items.get_key_value(namespace).into_iter().flat_map(move |(namespace, items)| items.iter().filter(move |(name, _)| filter.includes_type_name(TypeName::new(namespace, name)))).flat_map(move |(_, items)| items).cloned()
     }
 
+    fn unused(&self, filter: &str) -> bool {
+        // Match namespaces
+        if self.items.contains_key(filter) {
+            return false;
+        }
+
+        // Match type names
+        if let Some((namespace, name)) = filter.rsplit_once('.') {
+            if self.items.get(namespace).is_some_and(|items| items.contains_key(name)) {
+                return false;
+            }
+        }
+
+        // Match empty parent namespaces
+        for namespace in self.items.keys() {
+            if namespace.len() > filter.len() && namespace.starts_with(filter) && namespace.as_bytes()[filter.len()] == b'.' {
+                return false;
+            }
+        }
+
+        true
+    }
+
     fn get_item(&self, type_name: TypeName) -> impl Iterator<Item = Item> + '_ {
         if let Some(items) = self.items.get(type_name.namespace) {
             if let Some(items) = items.get(type_name.name) {

crates/tests/riddle/src/lib.rs

@@ -18,13 +18,15 @@ pub fn run_riddle(name: &str, dialect: &str, etc: &[&str]) -> Vec<windows_metada
     let before = std::fs::read_to_string(&rdl).expect("Failed to read input");
 
     // Convert .rdl to .winmd
+    std::fs::remove_file(&winmd).expect("Failed to delete output");
     let mut command = Command::new("cargo");
     command.args([
         "run", "-p", "riddle", "--", "--in", &rdl, "--out", &winmd, "--filter", "Test",
     ]);
     assert!(command.status().unwrap().success());
 
     // Convert .winmd back to .rdl
+    std::fs::remove_file(&rdl).expect("Failed to delete output");
     let mut command = Command::new("cargo");
     command.args([
         "run", "-p", "riddle", "--", "--in", &winmd, "--out", &rdl, "--filter", "Test", "--config",
@@ -37,6 +39,7 @@ pub fn run_riddle(name: &str, dialect: &str, etc: &[&str]) -> Vec<windows_metada
     assert_eq!(before, after, "no equal {}", rdl);
 
     // Convert .rdl to .rs
+    std::fs::remove_file(&rs).expect("Failed to delete output");
     let mut command = Command::new("cargo");
     command.args([
         "run", "-p", "riddle", "--", "--in", &rdl, "--out", &rs, "--filter", "Test",

crates/tests/standalone/build.rs

@@ -150,6 +150,8 @@ fn write_std(output: &str, filter: &[&str]) {
 }
 
 fn riddle(output: &str, filter: &[&str], config: &[&str]) {
+    std::fs::remove_file(output).expect("Failed to delete output");
+
     let mut command = std::process::Command::new("cargo");
 
     command.args([