feat(config): add workspace.extra_clippy_allows for generated bindings

Goldziher · Goldziher · commit be1e1656c4ea · 2026-07-02T16:23:32.000+02:00
Consumers can append clippy lints to allow in every generated Rust binding
file via [workspace] extra_clippy_allows. The list is merged (union, dedup)
on top of each backend's built-in default allow-list and emitted as a single
extra #![allow(...)] after the defaults. When absent or empty, generated
output is byte-identical to the previous behaviour.

Threaded through all 9 Rust-emitting backends (pyo3, napi, magnus, php,
rustler, extendr, wasm, dart, swift). Lets liter-llm allow single_match /
collapsible_match on its generated bindings without hand-editing.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **config**: `[workspace] extra_clippy_allows` — a string list of additional clippy lints
+  to allow in every generated Rust binding file.  Entries may be bare lint names
+  (`"single_match"`) or `clippy::`-prefixed (`"clippy::single_match"`); both forms are
+  accepted and normalised internally.  The configured lints are merged (union,
+  de-duplicated; defaults first, extras appended) with each backend's built-in default
+  allow-list, and a single extra `#![allow(...)]` attribute is emitted after the defaults.
+  When the list is absent or empty the generated output is byte-identical to the previous
+  behaviour.  Affected backends: pyo3, napi, magnus, php, rustler, extendr, wasm, dart,
+  swift.
+
+  Example:
+  ```toml
+  [workspace]
+  extra_clippy_allows = ["single_match", "collapsible_match"]
+  ```
+
 ## [0.30.10] - 2026-07-02
 
 ### Fixed
@@ -26,6 +44,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **chore**: consolidate the typos allowlist into `poly.toml` and drop dead configs.
 
+## [0.30.9] - 2026-07-02
+
 ### Fixed
 
 - **codegen/ffi**: complete the service-owner forward-declaration fix from 0.30.8. The new
diff --git a/schemas/alef.schema.json b/schemas/alef.schema.json
@@ -6902,6 +6902,14 @@
           "default": null,
           "description": "Default Elixir/Rustler backend settings."
         },
+        "extra_clippy_allows": {
+          "default": [],
+          "description": "Extra clippy lints to allow in every generated Rust binding file, merged\n(union, de-duplicated) with each backend's built-in default allow-list.\n\nEntries may be bare lint names (`\"single_match\"`) or `clippy::`-prefixed\n(`\"clippy::single_match\"`); both forms are accepted and normalised\ninternally.  When absent or empty the emitted allow-list is byte-identical\nto the backend default — no diff in consumers that do not set this field.\n\nExample:\n```toml\n[workspace]\nextra_clippy_allows = [\"single_match\", \"collapsible_match\"]\n```",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "ffi": {
           "anyOf": [
             {
@@ -7381,6 +7389,7 @@
           "ruby": "struct"
         },
         "elixir": null,
+        "extra_clippy_allows": [],
         "ffi": null,
         "format": {
           "command": null,
diff --git a/src/backends/dart/gen_rust_crate/mod.rs b/src/backends/dart/gen_rust_crate/mod.rs
@@ -115,6 +115,9 @@ fn emit_lib_rs(
     // works for both wrapped and unwrapped string keys/values.
     content.push_str("    clippy::useless_conversion,\n");
     content.push_str(")]\n");
+    if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+        content.push_str(&format!("#![{extra_attr}]\n"));
+    }
     // Declare frb_generated after the crate-level attrs so FRB doesn't inject it at line 1.
     content.push_str("mod frb_generated;\n");
     content.push_str("use flutter_rust_bridge::frb;\n");
diff --git a/src/backends/extendr/gen_bindings/mod.rs b/src/backends/extendr/gen_bindings/mod.rs
@@ -79,6 +79,9 @@ impl Backend for ExtendrBackend {
         let mut builder = RustFileBuilder::new().with_generated_header();
         builder.add_inner_attribute("allow(dead_code, unused_imports, unused_variables)");
         builder.add_inner_attribute("allow(clippy::too_many_arguments, clippy::let_unit_value, clippy::needless_borrow, clippy::map_identity, clippy::just_underscores_and_digits, clippy::unused_unit, clippy::unnecessary_cast, clippy::unwrap_or_default, clippy::derivable_impls, clippy::needless_borrows_for_generic_args, clippy::unnecessary_fallible_conversions)");
+        if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+            builder.add_inner_attribute(&extra_attr);
+        }
         builder.add_import("extendr_api::prelude::*");
         // HashMap is needed for fields of type HashMap<K, V> (extendr prelude does not re-export it)
         builder.add_import("std::collections::HashMap");
diff --git a/src/backends/magnus/gen_bindings/mod.rs b/src/backends/magnus/gen_bindings/mod.rs
@@ -127,6 +127,9 @@ impl Backend for MagnusBackend {
              clippy::needless_borrows_for_generic_args, clippy::unnecessary_fallible_conversions, \
              clippy::type_complexity, clippy::useless_conversion, clippy::clone_on_copy)",
         );
+        if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+            builder.add_inner_attribute(&extra_attr);
+        }
         builder.add_import(
             "magnus::{function, method, prelude::*, Error, Ruby, IntoValueFromNative, try_convert::TryConvertOwned}",
         );
diff --git a/src/backends/napi/gen_bindings/mod.rs b/src/backends/napi/gen_bindings/mod.rs
@@ -147,6 +147,9 @@ impl Backend for NapiBackend {
         builder.add_inner_attribute(
             "allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss, clippy::default_trait_access, clippy::useless_conversion, clippy::unsafe_derive_deserialize, clippy::must_use_candidate, clippy::return_self_not_must_use, clippy::use_self, clippy::missing_const_for_fn, clippy::missing_errors_doc, clippy::needless_pass_by_value, clippy::doc_markdown, clippy::derive_partial_eq_without_eq, clippy::uninlined_format_args, clippy::redundant_clone, clippy::implicit_clone, clippy::redundant_closure_for_method_calls, clippy::wildcard_imports, clippy::option_if_let_else, clippy::too_many_lines)",
         );
+        if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+            builder.add_inner_attribute(&extra_attr);
+        }
         builder.add_import("napi::*");
         builder.add_import("napi_derive::napi");
 
diff --git a/src/backends/php/gen_bindings/rust_bindings.rs b/src/backends/php/gen_bindings/rust_bindings.rs
@@ -188,6 +188,9 @@ pub(super) fn generate_bindings(api: &ApiSurface, config: &ResolvedCrateConfig)
     // PHP parameter names are lowerCamelCase; Rust complains about non-snake_case variables.
     builder.add_inner_attribute("allow(non_snake_case)");
     builder.add_inner_attribute("allow(clippy::too_many_arguments, clippy::let_unit_value, clippy::needless_borrow, clippy::map_identity, clippy::just_underscores_and_digits, clippy::unnecessary_cast, clippy::unused_unit, clippy::unwrap_or_default, clippy::derivable_impls, clippy::needless_borrows_for_generic_args, clippy::unnecessary_fallible_conversions, clippy::arc_with_non_send_sync, clippy::collapsible_if, clippy::clone_on_copy, clippy::should_implement_trait, clippy::useless_conversion)");
+    if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+        builder.add_inner_attribute(&extra_attr);
+    }
     builder.add_import("ext_php_rs::prelude::*");
 
     // Import serde_json when available (needed for serde-based param conversion)
diff --git a/src/backends/pyo3/gen_bindings/mod.rs b/src/backends/pyo3/gen_bindings/mod.rs
@@ -99,7 +99,7 @@ impl Backend for Pyo3Backend {
         let adapter_bodies = crate::adapters::build_adapter_bodies(config, Language::Python)?;
 
         let mut builder = RustFileBuilder::new().with_generated_header();
-        support_items::add_generated_module_attributes(&mut builder);
+        support_items::add_generated_module_attributes(&mut builder, &config.extra_clippy_allows);
         builder.add_import("pyo3::prelude::*");
         // Note: core_import and path_mapping crates are referenced via fully-qualified paths
         // in generated code (e.g. `core_import::TypeName`), so no bare `use crate_name;`
diff --git a/src/backends/pyo3/gen_bindings/support_items.rs b/src/backends/pyo3/gen_bindings/support_items.rs
@@ -1,6 +1,7 @@
 use crate::codegen::builder::RustFileBuilder;
+use crate::codegen::shared::format_extra_clippy_allows;
 
-pub(super) fn add_generated_module_attributes(builder: &mut RustFileBuilder) {
+pub(super) fn add_generated_module_attributes(builder: &mut RustFileBuilder, extras: &[String]) {
     // Suppress documentation and cast lints in generated code. Python stubs carry
     // docs, and numeric casts are intentional FFI conversions.
     builder.add_inner_attribute("allow(missing_docs)");
@@ -14,6 +15,9 @@ pub(super) fn add_generated_module_attributes(builder: &mut RustFileBuilder) {
     );
     builder.add_inner_attribute("allow(clippy::multiple_unsafe_ops_per_block)");
     builder.add_inner_attribute("allow(unsafe_code)");
+    if let Some(extra_attr) = format_extra_clippy_allows(extras) {
+        builder.add_inner_attribute(&extra_attr);
+    }
 }
 
 pub(super) fn add_py_visitor_ref(builder: &mut RustFileBuilder) {
diff --git a/src/backends/rustler/gen_bindings/native.rs b/src/backends/rustler/gen_bindings/native.rs
@@ -106,6 +106,9 @@ pub(super) fn generate_bindings(api: &ApiSurface, config: &ResolvedCrateConfig)
     let mut builder = RustFileBuilder::new().with_generated_header();
     builder.add_inner_attribute("allow(dead_code, unused_imports, unused_variables)");
     builder.add_inner_attribute("allow(clippy::too_many_arguments, clippy::let_unit_value, clippy::needless_borrow, clippy::map_identity, clippy::just_underscores_and_digits, clippy::unused_unit, clippy::unnecessary_cast, clippy::unwrap_or_default, clippy::derivable_impls, clippy::needless_borrows_for_generic_args, clippy::unnecessary_fallible_conversions)");
+    if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+        builder.add_inner_attribute(&extra_attr);
+    }
     builder.add_import("rustler::ResourceArc");
     builder.add_import("rustler::Encoder");
 
diff --git a/src/backends/swift/gen_rust_crate/mod.rs b/src/backends/swift/gen_rust_crate/mod.rs
@@ -217,7 +217,11 @@ fn emit_lib_rs(
     // swift-bridge can map it to a Swift initializer; deriving Default doesn't
     // help downstream because Swift can't call it through the bridge.
     out.push_str("    clippy::new_without_default,\n");
-    out.push_str(")]\n\n");
+    out.push_str(")]\n");
+    if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+        out.push_str(&format!("#![{extra_attr}]\n"));
+    }
+    out.push('\n');
 
     // Emit the process-wide tokio runtime accessor. Async swift-bridge wrappers
     // share this single runtime instead of building one per call — the per-call
diff --git a/src/backends/wasm/gen_bindings/mod.rs b/src/backends/wasm/gen_bindings/mod.rs
@@ -220,6 +220,9 @@ impl Backend for WasmBackend {
             "allow(dead_code, unused_imports, unused_variables, unreachable_patterns, missing_docs)",
         );
         builder.add_inner_attribute("allow(clippy::too_many_arguments, clippy::let_unit_value, clippy::needless_borrow, clippy::map_identity, clippy::just_underscores_and_digits, clippy::unused_unit, clippy::unnecessary_cast, clippy::unwrap_or_default, clippy::derivable_impls, clippy::needless_borrows_for_generic_args, clippy::unnecessary_fallible_conversions, clippy::useless_conversion, clippy::arc_with_non_send_sync, clippy::collapsible_if, clippy::clone_on_copy, clippy::should_implement_trait, clippy::await_holding_refcell_ref, clippy::new_without_default)");
+        if let Some(extra_attr) = crate::codegen::shared::format_extra_clippy_allows(&config.extra_clippy_allows) {
+            builder.add_inner_attribute(&extra_attr);
+        }
         builder.add_import("wasm_bindgen::prelude::*");
 
         // Hand-written Rust modules: declare `pub mod <name>;` at the top of lib.rs
diff --git a/src/codegen/shared.rs b/src/codegen/shared.rs
@@ -610,3 +610,35 @@ fn config_constructor_parts_inner(
 
     (param_list, defaults, assignments.join(", "))
 }
+
+/// Format extra clippy allows for insertion into generated Rust binding files.
+///
+/// Accepts bare lint names (`"single_match"`) or `clippy::`-prefixed names
+/// (`"clippy::single_match"`); both forms are normalised to the `clippy::` prefix.
+///
+/// Returns `None` when `extras` is empty — callers must skip emission entirely in
+/// that case so output is byte-identical to the no-config baseline.
+///
+/// Returns `Some(attr)` where `attr` is the inner content of an `allow(...)` call,
+/// e.g. `"allow(clippy::single_match, clippy::collapsible_match)"`.  Pass this
+/// directly to [`crate::codegen::builder::RustFileBuilder::add_inner_attribute`]
+/// or format it into a raw `#![allow(...)]` attribute string.
+pub fn format_extra_clippy_allows(extras: &[String]) -> Option<String> {
+    if extras.is_empty() {
+        return None;
+    }
+    let mut seen = HashSet::new();
+    let normalized: Vec<String> = extras
+        .iter()
+        .map(|s| {
+            let trimmed = s.trim();
+            if trimmed.starts_with("clippy::") {
+                trimmed.to_string()
+            } else {
+                format!("clippy::{trimmed}")
+            }
+        })
+        .filter(|s| seen.insert(s.clone()))
+        .collect();
+    Some(format!("allow({})", normalized.join(", ")))
+}
diff --git a/src/core/config/new_config.rs b/src/core/config/new_config.rs
@@ -314,6 +314,7 @@ impl NewAlefConfig {
             suppress_validation_codes: krate.suppress_validation_codes.clone(),
             untagged_union_text_types: krate.untagged_union_text_types.clone(),
             poly: ws.poly.clone(),
+            extra_clippy_allows: ws.extra_clippy_allows.clone(),
         })
     }
 }
diff --git a/src/core/config/resolved/mod.rs b/src/core/config/resolved/mod.rs
@@ -177,6 +177,10 @@ pub struct ResolvedCrateConfig {
     /// config.  Every resolved crate receives the same repo-wide poly settings.
     /// The poly emitter merges these into its generated output.
     pub poly: PolyConfig,
+
+    /// Extra clippy lints to allow in generated Rust binding files, inherited
+    /// from `[workspace] extra_clippy_allows`. Empty by default.
+    pub extra_clippy_allows: Vec<String>,
 }
 
 impl ResolvedCrateConfig {
diff --git a/src/core/config/workspace.rs b/src/core/config/workspace.rs
@@ -255,6 +255,22 @@ pub struct WorkspaceConfig {
     /// See [`PolyConfig`] for the full set of configurable knobs.
     #[serde(default)]
     pub poly: PolyConfig,
+
+    /// Extra clippy lints to allow in every generated Rust binding file, merged
+    /// (union, de-duplicated) with each backend's built-in default allow-list.
+    ///
+    /// Entries may be bare lint names (`"single_match"`) or `clippy::`-prefixed
+    /// (`"clippy::single_match"`); both forms are accepted and normalised
+    /// internally.  When absent or empty the emitted allow-list is byte-identical
+    /// to the backend default — no diff in consumers that do not set this field.
+    ///
+    /// Example:
+    /// ```toml
+    /// [workspace]
+    /// extra_clippy_allows = ["single_match", "collapsible_match"]
+    /// ```
+    #[serde(default)]
+    pub extra_clippy_allows: Vec<String>,
 }
 
 #[cfg(test)]
diff --git a/src/core/hash/tests.rs b/src/core/hash/tests.rs
@@ -415,6 +415,7 @@ fn crate_sources_hash_differs_across_crates_with_disjoint_sources() {
         suppress_validation_codes: Vec::new(),
         untagged_union_text_types: vec![],
         poly: Default::default(),
+        extra_clippy_allows: vec![],
     };
 
     let cfg_a = make_cfg("alpha", vec![a]);
@@ -517,6 +518,7 @@ fn crate_sources_hash_includes_source_crates() {
                 suppress_validation_codes: Vec::new(),
                 untagged_union_text_types: vec![],
                 poly: Default::default(),
+                extra_clippy_allows: vec![],
             }
         };
 
@@ -622,6 +624,7 @@ fn compute_crate_sources_hash_dedupes_overlapping_paths() {
                 suppress_validation_codes: Vec::new(),
                 untagged_union_text_types: vec![],
                 poly: Default::default(),
+                extra_clippy_allows: vec![],
             }
         };
 
@@ -717,6 +720,7 @@ fn compute_crate_sources_hash_is_order_independent() {
             suppress_validation_codes: Vec::new(),
             untagged_union_text_types: vec![],
             poly: Default::default(),
+            extra_clippy_allows: vec![],
         }
     };
 
diff --git a/tests/workspace_extra_clippy_allows_test.rs b/tests/workspace_extra_clippy_allows_test.rs
