De-dup filter implementations

Author: QuantumSegfault

crates/c/src/lib.rs

@@ -10,8 +10,8 @@ use wit_bindgen_core::abi::{
     self, AbiVariant, Bindgen, Bitcast, Instruction, LiftLower, WasmSignature, WasmType,
 };
 use wit_bindgen_core::{
-    AnonymousTypeGenerator, AsyncFilterSet, Direction, Files, InterfaceGenerator as _, Ns,
-    WorldGenerator, dealias, uwrite, uwriteln, wit_parser::*,
+    AnonymousTypeGenerator, AsyncFilterSet, Direction, Files, FilterSet, InterfaceGenerator as _,
+    Ns, WorldGenerator, dealias, uwrite, uwriteln, wit_parser::*,
 };
 use wit_component::StringEncoding;
 
@@ -2077,7 +2077,7 @@ impl InterfaceGenerator<'_> {
             .r#gen
             .opts
             .async_
-            .is_async(self.resolve, interface_name, func, true);
+            .apply_rules(self.resolve, interface_name, func, true);
         if async_ {
             self.r#gen.needs_async = true;
         }
@@ -2246,7 +2246,7 @@ impl InterfaceGenerator<'_> {
             .r#gen
             .opts
             .async_
-            .is_async(self.resolve, interface_name, func, false);
+            .apply_rules(self.resolve, interface_name, func, false);
 
         let (variant, prefix) = if async_ {
             self.r#gen.needs_async = true;

crates/core/src/async_.rs

@@ -1,8 +1,9 @@
-use anyhow::{Result, bail};
-use std::collections::HashSet;
 use std::fmt;
+use std::{collections::HashSet, fmt::Write};
 use wit_parser::{Function, FunctionKind, Resolve, WorldKey};
 
+use crate::filter::{FilterMode, FilterRule, FilterSet, FilterTarget};
+
 /// Structure used to parse the command line argument `--async` consistently
 /// across guest generators.
 #[cfg_attr(feature = "clap", derive(clap::Parser))]
@@ -33,9 +34,9 @@ pub struct AsyncFilterSet {
         arg(
             long = "async",
             value_parser = parse_async,
-            value_delimiter =',',
+            value_delimiter = ',',
             value_name = "FILTER",
-        ),
+        )
     )]
     #[cfg_attr(feature = "serde", serde(rename = "async"))]
     async_: Vec<Async>,
@@ -45,26 +46,35 @@ pub struct AsyncFilterSet {
     used_options: HashSet<usize>,
 }
 
-#[cfg(feature = "clap")]
-fn parse_async(s: &str) -> Result<Async, String> {
-    Ok(Async::parse(s))
-}
+impl FilterSet for AsyncFilterSet {
+    type Mode = bool;
+    type Filter = AsyncFilter;
 
-impl AsyncFilterSet {
-    /// Returns a set where all functions should be async or not depending on
-    /// `async_` provided.
-    pub fn all(async_: bool) -> AsyncFilterSet {
-        AsyncFilterSet {
-            async_: vec![Async {
-                enabled: async_,
-                filter: AsyncFilter::All,
-            }],
+    fn new(rules: Vec<Async>) -> Self {
+        Self {
+            async_: rules,
             used_options: HashSet::new(),
         }
     }
 
-    /// Returns whether the `func` provided is to be bound `async` or not.
-    pub fn is_async(
+    fn rules(&self) -> &[Async] {
+        &self.async_
+    }
+    fn rules_mut(&mut self) -> &mut Vec<Async> {
+        &mut self.async_
+    }
+    fn used_options(&self) -> &HashSet<usize> {
+        &self.used_options
+    }
+    fn used_options_mut(&mut self) -> &mut HashSet<usize> {
+        &mut self.used_options
+    }
+
+    fn option_name() -> &'static str {
+        "async"
+    }
+
+    fn apply_rules(
         &mut self,
         resolve: &Resolve,
         interface: Option<&WorldKey>,
@@ -75,11 +85,12 @@ impl AsyncFilterSet {
             Some(key) => format!("{}#{}", resolve.name_world_key(key), func.name),
             None => func.name.clone(),
         };
+
         for (i, opt) in self.async_.iter().enumerate() {
             let name = match &opt.filter {
                 AsyncFilter::All => {
                     self.used_options.insert(i);
-                    return opt.enabled;
+                    return opt.mode;
                 }
                 AsyncFilter::Function(s) => s,
                 AsyncFilter::Import(s) => {
@@ -97,95 +108,77 @@ impl AsyncFilterSet {
             };
             if *name == name_to_test {
                 self.used_options.insert(i);
-                return opt.enabled;
+                return opt.mode;
             }
         }
 
-        match &func.kind {
-            FunctionKind::Freestanding
-            | FunctionKind::Method(_)
-            | FunctionKind::Static(_)
-            | FunctionKind::Constructor(_) => false,
+        matches!(
+            func.kind,
             FunctionKind::AsyncFreestanding
-            | FunctionKind::AsyncMethod(_)
-            | FunctionKind::AsyncStatic(_) => true,
-        }
-    }
-
-    /// Intended to be used in the header comment of generated code to help
-    /// indicate what options were specified.
-    pub fn debug_opts(&self) -> impl Iterator<Item = String> + '_ {
-        self.async_.iter().map(|opt| opt.to_string())
+                | FunctionKind::AsyncMethod(_)
+                | FunctionKind::AsyncStatic(_)
+        )
     }
+}
 
-    /// Tests whether all `--async` options were used throughout bindings
-    /// generation, returning an error if any were unused.
-    pub fn ensure_all_used(&self) -> Result<()> {
-        for (i, opt) in self.async_.iter().enumerate() {
-            if self.used_options.contains(&i) {
-                continue;
-            }
-            if !matches!(opt.filter, AsyncFilter::All) {
-                bail!("unused async option: {opt}");
-            }
-        }
-        Ok(())
-    }
+#[cfg(feature = "clap")]
+fn parse_async(s: &str) -> Result<Async, String> {
+    Ok(Async::parse(s))
+}
 
-    /// Returns whether any option explicitly requests that async is enabled.
+impl AsyncFilterSet {
     pub fn any_enabled(&self) -> bool {
-        self.async_.iter().any(|o| o.enabled)
+        self.async_.iter().any(|o| o.mode)
     }
+}
+
+type Async = FilterRule<bool, AsyncFilter>;
 
-    /// Pushes a new option into this set.
-    pub fn push(&mut self, directive: &str) {
-        self.async_.push(Async::parse(directive));
+impl FilterMode for bool {
+    fn parse(s: &str) -> (Self, &str) {
+        match s.strip_prefix('-') {
+            Some(rest) => (false, rest),
+            None => (true, s),
+        }
+    }
+    fn fmt_prefix(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if *self {
+            f.write_char('-')?;
+        }
+        Ok(())
     }
 }
 
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize))]
-struct Async {
-    enabled: bool,
-    filter: AsyncFilter,
+pub enum AsyncFilter {
+    All,
+    Function(String),
+    Import(String),
+    Export(String),
 }
 
-impl Async {
-    fn parse(s: &str) -> Async {
-        let (s, enabled) = match s.strip_prefix('-') {
-            Some(s) => (s, false),
-            None => (s, true),
-        };
-        let filter = match s {
+impl FilterTarget for AsyncFilter {
+    fn parse(s: &str) -> Self {
+        match s {
             "all" => AsyncFilter::All,
             other => match other.strip_prefix("import:") {
-                Some(s) => AsyncFilter::Import(s.to_string()),
+                Some(sub) => AsyncFilter::Import(sub.to_string()),
                 None => match other.strip_prefix("export:") {
-                    Some(s) => AsyncFilter::Export(s.to_string()),
-                    None => AsyncFilter::Function(s.to_string()),
+                    Some(sub) => AsyncFilter::Export(sub.to_string()),
+                    None => AsyncFilter::Function(other.to_string()),
                 },
             },
-        };
-        Async { enabled, filter }
+        }
     }
-}
 
-impl fmt::Display for Async {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if !self.enabled {
-            write!(f, "-")?;
-        }
-        self.filter.fmt(f)
+    fn all() -> AsyncFilter {
+        AsyncFilter::All
     }
-}
 
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
-enum AsyncFilter {
-    All,
-    Function(String),
-    Import(String),
-    Export(String),
+    fn is_all(&self) -> bool {
+        matches!(self, AsyncFilter::All)
+    }
 }
 
 impl fmt::Display for AsyncFilter {