fix lint issues

Author: romnn

Cargo.lock

@@ -10,6 +10,10 @@ use std::process::Command;
 /// obtain the active cfg set, and `cfg-expr` to parse and evaluate expressions.
 pub trait CfgEvaluator {
     /// Return whether the given cfg expression matches the provided target.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the cfg expression cannot be parsed or evaluated.
     fn matches(&mut self, cfg_expr: &str, target: &TargetTriple) -> eyre::Result<bool>;
 }
 
@@ -106,6 +110,13 @@ impl RustcCfgEvaluator {
     }
 }
 
+fn endian_str(e: cfg_expr::targets::Endian) -> &'static str {
+    match e {
+        cfg_expr::targets::Endian::big => "big",
+        cfg_expr::targets::Endian::little => "little",
+    }
+}
+
 impl CfgEvaluator for RustcCfgEvaluator {
     fn matches(&mut self, cfg_expr: &str, target: &TargetTriple) -> eyre::Result<bool> {
         let set = self.cfg_set_for(target)?;
@@ -114,13 +125,6 @@ impl CfgEvaluator for RustcCfgEvaluator {
             .wrap_err_with(|| format!("failed to parse cfg expression `{cfg_expr}`"))?;
         Self::validate_supported(&expr)?;
 
-        fn endian_str(e: &cfg_expr::targets::Endian) -> &'static str {
-            match e {
-                cfg_expr::targets::Endian::big => "big",
-                cfg_expr::targets::Endian::little => "little",
-            }
-        }
-
         Ok(expr.eval(|pred| match pred {
             Predicate::Target(tp) => {
                 // For target_* predicates, `rustc --print cfg` provides exact
@@ -143,7 +147,7 @@ impl CfgEvaluator for RustcCfgEvaluator {
                     }
                     cfg_expr::expr::TargetPredicate::Abi(a) => set.has_kv("target_abi", a.as_ref()),
                     cfg_expr::expr::TargetPredicate::Endian(e) => {
-                        set.has_kv("target_endian", endian_str(e))
+                        set.has_kv("target_endian", endian_str(*e))
                     }
                     cfg_expr::expr::TargetPredicate::Panic(p) => set.has_kv("panic", p.as_ref()),
                     cfg_expr::expr::TargetPredicate::PointerWidth(w) => {

src/cfg_eval.rs

@@ -15,8 +15,8 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 /// `[workspace.metadata.cargo-feature-combinations]` instead.
 #[derive(Serialize, Deserialize, Default, Debug, Clone)]
 pub struct Config {
-    #[serde(default)]
     /// Feature sets that must be tested in isolation.
+    #[serde(default)]
     pub isolated_feature_sets: Vec<HashSet<String>>,
     /// Formerly named `denylist`
     #[serde(default)]
@@ -57,23 +57,23 @@ pub struct Config {
     /// Formerly named `exact_combinations`
     #[serde(default)]
     pub include_feature_sets: Vec<HashSet<String>>,
-    #[serde(default)]
     /// Explicitly allowed feature sets.
-    pub allow_feature_sets: Vec<HashSet<String>>,
     #[serde(default)]
+    pub allow_feature_sets: Vec<HashSet<String>>,
     /// When enabled, disallow generating the empty feature set.
-    pub no_empty_feature_set: bool,
     #[serde(default)]
+    pub no_empty_feature_set: bool,
     /// Arbitrary user-defined matrix values forwarded to the runner.
+    #[serde(default)]
     pub matrix: HashMap<String, serde_json::Value>,
 
     /// Target-specific configuration overrides.
     ///
     /// This is read from `[package.metadata.cargo-feature-combinations.target.'cfg(...)']`.
     #[serde(default)]
     pub target: BTreeMap<String, TargetOverride>,
-    #[serde(flatten)]
     /// Deprecated configuration keys (kept for backwards compatibility).
+    #[serde(flatten)]
     pub deprecated: DeprecatedConfig,
 }
 
@@ -88,56 +88,56 @@ pub struct TargetOverride {
     #[serde(default)]
     pub replace: bool,
 
-    #[serde(default)]
     /// Patch operations for [`Config::isolated_feature_sets`].
-    pub isolated_feature_sets: Option<FeatureSetVecPatch>,
     #[serde(default)]
+    pub isolated_feature_sets: Option<FeatureSetVecPatch>,
     /// Patch operations for [`Config::exclude_features`].
-    pub exclude_features: Option<StringSetPatch>,
     #[serde(default)]
+    pub exclude_features: Option<StringSetPatch>,
     /// Patch operations for [`Config::include_features`].
-    pub include_features: Option<StringSetPatch>,
     #[serde(default)]
+    pub include_features: Option<StringSetPatch>,
     /// Patch operations for [`Config::only_features`].
-    pub only_features: Option<StringSetPatch>,
     #[serde(default)]
+    pub only_features: Option<StringSetPatch>,
     /// Override for [`Config::skip_optional_dependencies`].
-    pub skip_optional_dependencies: Option<bool>,
     #[serde(default)]
+    pub skip_optional_dependencies: Option<bool>,
     /// Patch operations for [`Config::exclude_feature_sets`].
-    pub exclude_feature_sets: Option<FeatureSetVecPatch>,
     #[serde(default)]
+    pub exclude_feature_sets: Option<FeatureSetVecPatch>,
     /// Patch operations for [`Config::include_feature_sets`].
-    pub include_feature_sets: Option<FeatureSetVecPatch>,
     #[serde(default)]
+    pub include_feature_sets: Option<FeatureSetVecPatch>,
     /// Patch operations for [`Config::allow_feature_sets`].
-    pub allow_feature_sets: Option<FeatureSetVecPatch>,
     #[serde(default)]
+    pub allow_feature_sets: Option<FeatureSetVecPatch>,
     /// Override for [`Config::no_empty_feature_set`].
-    pub no_empty_feature_set: Option<bool>,
     #[serde(default)]
+    pub no_empty_feature_set: Option<bool>,
     /// Merge override for [`Config::matrix`].
+    #[serde(default)]
     pub matrix: Option<HashMap<String, serde_json::Value>>,
 }
 
-#[derive(Serialize, Deserialize, Default, Debug, Clone)]
 /// Workspace-wide configuration for `cargo-feature-combinations`.
+#[derive(Serialize, Deserialize, Default, Debug, Clone)]
 pub struct WorkspaceConfig {
     /// List of package names to exclude from the workspace analysis.
     #[serde(default)]
     pub exclude_packages: HashSet<String>,
 }
 
-#[derive(Serialize, Deserialize, Default, Debug, Clone)]
 /// Deprecated configuration keys kept for backwards compatibility.
+#[derive(Serialize, Deserialize, Default, Debug, Clone)]
 pub struct DeprecatedConfig {
-    #[serde(default)]
     /// Former name of [`Config::exclude_feature_sets`].
-    pub skip_feature_sets: Vec<HashSet<String>>,
     #[serde(default)]
+    pub skip_feature_sets: Vec<HashSet<String>>,
     /// Former name of [`Config::exclude_features`].
-    pub denylist: HashSet<String>,
     #[serde(default)]
+    pub denylist: HashSet<String>,
     /// Former name of [`Config::include_feature_sets`].
+    #[serde(default)]
     pub exact_combinations: Vec<HashSet<String>>,
 }

src/config.rs

@@ -16,30 +16,30 @@ pub enum StringSetPatch {
     Override(HashSet<String>),
     /// Explicit patch syntax: `key = { override = [...], add = [...], remove = [...] }`.
     Patch {
-        #[serde(default)]
         /// If present, replace the entire value instead of applying add/remove.
-        r#override: Option<HashSet<String>>,
         #[serde(default)]
+        r#override: Option<HashSet<String>>,
         /// Values to add to the base set.
-        add: HashSet<String>,
         #[serde(default)]
+        add: HashSet<String>,
         /// Values to remove from the base set.
+        #[serde(default)]
         remove: HashSet<String>,
     },
 }
 
 impl StringSetPatch {
-    #[must_use]
     /// Return the override value, if the patch is an override.
+    #[must_use]
     pub fn override_value(&self) -> Option<&HashSet<String>> {
         match self {
             Self::Override(v) => Some(v),
             Self::Patch { r#override, .. } => r#override.as_ref(),
         }
     }
 
-    #[must_use]
     /// Return the set of values to add.
+    #[must_use]
     pub fn add_values(&self) -> &HashSet<String> {
         static EMPTY: std::sync::LazyLock<HashSet<String>> = std::sync::LazyLock::new(HashSet::new);
         match self {
@@ -48,8 +48,8 @@ impl StringSetPatch {
         }
     }
 
-    #[must_use]
     /// Return the set of values to remove.
+    #[must_use]
     pub fn remove_values(&self) -> &HashSet<String> {
         static EMPTY: std::sync::LazyLock<HashSet<String>> = std::sync::LazyLock::new(HashSet::new);
         match self {
@@ -58,8 +58,8 @@ impl StringSetPatch {
         }
     }
 
-    #[must_use]
     /// Return `true` if the patch contains any add/remove operations.
+    #[must_use]
     pub fn has_add_or_remove(&self) -> bool {
         !self.add_values().is_empty() || !self.remove_values().is_empty()
     }
@@ -73,30 +73,30 @@ pub enum FeatureSetVecPatch {
     Override(Vec<HashSet<String>>),
     /// Explicit patch syntax.
     Patch {
-        #[serde(default)]
         /// If present, replace the entire list instead of applying add/remove.
-        r#override: Option<Vec<HashSet<String>>>,
         #[serde(default)]
+        r#override: Option<Vec<HashSet<String>>>,
         /// Feature sets to append.
-        add: Vec<HashSet<String>>,
         #[serde(default)]
+        add: Vec<HashSet<String>>,
         /// Feature sets to remove.
+        #[serde(default)]
         remove: Vec<HashSet<String>>,
     },
 }
 
 impl FeatureSetVecPatch {
-    #[must_use]
     /// Return the override value, if the patch is an override.
+    #[must_use]
     pub fn override_value(&self) -> Option<&Vec<HashSet<String>>> {
         match self {
             Self::Override(v) => Some(v),
             Self::Patch { r#override, .. } => r#override.as_ref(),
         }
     }
 
-    #[must_use]
     /// Return the feature sets to add.
+    #[must_use]
     pub fn add_values(&self) -> &[HashSet<String>] {
         static EMPTY: std::sync::LazyLock<Vec<HashSet<String>>> =
             std::sync::LazyLock::new(Vec::new);
@@ -106,8 +106,8 @@ impl FeatureSetVecPatch {
         }
     }
 
-    #[must_use]
     /// Return the feature sets to remove.
+    #[must_use]
     pub fn remove_values(&self) -> &[HashSet<String>] {
         static EMPTY: std::sync::LazyLock<Vec<HashSet<String>>> =
             std::sync::LazyLock::new(Vec::new);
@@ -117,8 +117,8 @@ impl FeatureSetVecPatch {
         }
     }
 
-    #[must_use]
     /// Return `true` if the patch contains any add/remove operations.
+    #[must_use]
     pub fn has_add_or_remove(&self) -> bool {
         !self.add_values().is_empty() || !self.remove_values().is_empty()
     }