Fix more clippy issues.

crates/backend_c/src/converter.rs

@@ -98,7 +98,7 @@ impl CTypeConverter for Converter {
 
     fn fnpointer_to_typename(&self, x: &FnPointerType) -> String {
         let prefixed = format!("{}fptr", self.config().prefix);
-        vec![prefixed, safe_name(&x.internal_name())].join("_")
+        [prefixed, safe_name(&x.internal_name())].join("_")
     }
 
     fn to_type_specifier(&self, x: &CType) -> String {

crates/backend_c/src/lib.rs

@@ -109,6 +109,7 @@
 //! #endif /* example_library */
 //!
 //! ```
+#![allow(clippy::test_attr_in_doctest)]
 
 use interoptopus::writer::IndentWriter;
 use interoptopus::Interop;

crates/backend_c/src/writer.rs

@@ -98,7 +98,7 @@ pub trait CWriter {
 
         let mut params = Vec::new();
 
-        for (_, p) in function.signature().params().iter().enumerate() {
+        for p in function.signature().params().iter() {
             match p.the_type() {
                 CType::Array(a) => {
                     params.push(format!(
@@ -141,17 +141,16 @@ pub trait CWriter {
 
         let mut params = Vec::new();
 
-        for (_, p) in function.signature().params().iter().enumerate() {
+        for p in function.signature().params().iter() {
             match p.the_type() {
                 CType::Array(a) => {
                     params.push(format!("{} [{}]", self.converter().to_type_specifier(a.array_type()), a.len(),));
                 }
                 _ => {
-                    params.push(format!("{}", self.converter().to_type_specifier(p.the_type()),));
+                    params.push(self.converter().to_type_specifier(p.the_type()).to_string());
                 }
             }
         }
-
         indented!(w, r#"typedef {} (*{})({});"#, rval, name, params.join(", "))?;
 
         Ok(())

crates/backend_cpython/src/lib.rs

@@ -132,6 +132,8 @@
 //!
 //! ```
 
+#![allow(clippy::test_attr_in_doctest)]
+
 use interoptopus::writer::IndentWriter;
 use interoptopus::Interop;
 use interoptopus::{Error, Inventory};

crates/backend_cpython/src/writer.rs

@@ -109,10 +109,7 @@ pub trait PythonWriter {
             indented!(w, [_], r#""""{}""""#, documentation)?;
         }
 
-        match c.repr().layout() {
-            Layout::Packed => indented!(w, [_], r#"_pack_ = 1"#)?,
-            _ => {}
-        }
+        if c.repr().layout() == Layout::Packed { indented!(w, [_], r#"_pack_ = 1"#)? }
 
         let alignment = c.repr().alignment();
         if let Some(align) = alignment {

crates/backend_csharp/src/converter.rs

@@ -91,7 +91,7 @@ pub trait CSharpTypeConverter {
 
     /// Converts an Rust `fn()` to a C# delegate name such as `InteropDelegate`.
     fn fnpointer_to_typename(&self, x: &FnPointerType) -> String {
-        vec!["InteropDelegate".to_string(), safe_name(&x.internal_name())].join("_")
+        ["InteropDelegate".to_string(), safe_name(&x.internal_name())].join("_")
     }
 
     /// Converts the `u32` part in a Rust field `x: u32` to a C# equivalent. Might convert pointers to `IntPtr`.

crates/backend_csharp/src/lib.rs

@@ -113,6 +113,8 @@
 //! }
 //! ```
 
+#![allow(clippy::test_attr_in_doctest)]
+
 use interoptopus::writer::IndentWriter;
 use interoptopus::Interop;
 use interoptopus::{Error, Inventory};

crates/backend_csharp/src/overloads/dotnet.rs

@@ -223,7 +223,7 @@ impl OverloadWriter for DotNet {
         };
 
         let mut params = Vec::new();
-        for (_, p) in function.signature().params().iter().enumerate() {
+        for p in function.signature().params().iter() {
             let name = p.name();
             let native = self.pattern_to_native_in_signature(&h, p);
             let the_type = h.converter.function_parameter_to_csharp_typename(p);

crates/backend_csharp/src/overloads/unity.rs

@@ -59,7 +59,7 @@ impl Unity {
                 TypePattern::Slice(p) => {
                     let element_type = p
                         .fields()
-                        .get(0)
+                        .first()
                         .expect("First parameter must exist")
                         .the_type()
                         .try_deref_pointer()
@@ -70,7 +70,7 @@ impl Unity {
                 TypePattern::SliceMut(p) => {
                     let element_type = p
                         .fields()
-                        .get(0)
+                        .first()
                         .expect("First parameter must exist")
                         .the_type()
                         .try_deref_pointer()
@@ -85,7 +85,7 @@ impl Unity {
                     TypePattern::Slice(p) => {
                         let element_type = p
                             .fields()
-                            .get(0)
+                            .first()
                             .expect("First parameter must exist")
                             .the_type()
                             .try_deref_pointer()
@@ -96,7 +96,7 @@ impl Unity {
                     TypePattern::SliceMut(p) => {
                         let element_type = p
                             .fields()
-                            .get(0)
+                            .first()
                             .expect("First parameter must exist")
                             .the_type()
                             .try_deref_pointer()
@@ -125,7 +125,7 @@ impl Unity {
         );
 
         let mut params = Vec::new();
-        for (_, p) in function.signature().params().iter().enumerate() {
+        for p in function.signature().params().iter() {
             let name = p.name();
             let the_type = match p.the_type() {
                 CType::FnPointer(_) => "IntPtr".to_string(),
@@ -248,7 +248,7 @@ impl OverloadWriter for Unity {
         };
 
         let mut params = Vec::new();
-        for (_, p) in function.signature().params().iter().enumerate() {
+        for p in function.signature().params().iter() {
             let name = p.name();
             let native = self.pattern_to_native_in_signature(&h, p, function.signature());
             let the_type = h.converter.function_parameter_to_csharp_typename(p);

crates/backend_csharp/src/writer.rs

@@ -180,7 +180,7 @@ pub trait CSharpWriter {
         );
 
         let mut params = Vec::new();
-        for (_, p) in function.signature().params().iter().enumerate() {
+        for p in function.signature().params().iter() {
             let the_type = self.converter().function_parameter_to_csharp_typename(p);
             let name = p.name();
 

crates/core/src/lib.rs

@@ -155,12 +155,12 @@
 //!
 //! - Submit small bug fixes directly. Major changes should be issues first.
 //! - Anything that makes previously working bindings change behavior or stop compiling
-//! is a major change;
+//!   is a major change;
 //! - This doesn't mean we're opposed to breaking stuff just that
-//! we'd like to talk about it before it happens.
+//!   we'd like to talk about it before it happens.
 //! - New features or patterns must be materialized in the reference project and accompanied by
-//! an interop test (i.e., a backend test running C# / Python against a DLL invoking that code)
-//! in at least one included backend.
+//!   an interop test (i.e., a backend test running C# / Python against a DLL invoking that code)
+//!   in at least one included backend.
 //!
 //! [Latest Version]: https://img.shields.io/crates/v/interoptopus.svg
 //! [crates.io]: https://crates.io/crates/interoptopus

crates/core/src/patterns/api_guard.rs

@@ -45,7 +45,7 @@
 //!
 //! - is based on the signatures of the involved functions, types and constants,
 //! - is expected to change when the API changes, e.g., functions, types, fields, ... are added
-//! changed or removed,
+//!   changed or removed,
 //! - will even react to benign API changes (e.g., just adding functions),
 //! - might even react to documentation changes (subject to change; feedback welcome).
 //!

crates/core/src/patterns/callbacks.rs

@@ -37,10 +37,10 @@
 //! The macro [**`callback`**](crate::callback) enables two use cases:
 //!
 //! - On the **Rust** side it will generate a new function-pointer type with better compatibility
-//! with respect to lifetimes in signatures, and accepting an unlimited number of args.
-//!- On the **FFI side** a _properly named_ callback (delegate, function pointer ...) type can be
-//! produced (e.g., `MyCallback`), instead of one where it's name is just a generic concatenation
-//! of all used parameters (e.g., `InteropDelegate_fn_i32_i32`).
+//!   with respect to lifetimes in signatures, and accepting an unlimited number of args.
+//! - On the **FFI side** a _properly named_ callback (delegate, function pointer ...) type can be
+//!   produced (e.g., `MyCallback`), instead of one where it's name is just a generic concatenation
+//!   of all used parameters (e.g., `InteropDelegate_fn_i32_i32`).
 //!
 //!
 //! # Why we need the macro `callback!`
@@ -127,7 +127,7 @@ impl NamedCallback {
 
     /// Creates a new named callback with the given meta.
     pub fn with_meta(callback: FnPointerType, meta: Meta) -> Self {
-        if let None = callback.name() {
+        if callback.name().is_none() {
             panic!("The pointer provided to a named callback must have a name.")
         }
         Self { fnpointer: callback, meta }

crates/core/src/patterns/mod.rs

@@ -50,24 +50,24 @@
 //! That means a backend will handle a pattern in one of three ways:
 //!
 //! - The pattern is **supported** and the backend will generate the raw, underlying type and / or
-//! a language-specific abstraction that safely and conveniently handles it. Examples
-//! include converting an [`CStrPointer`](string) to a C# `string`, or a [`service`](crate::patterns::service)
-//! to a Python `class`.
+//!   a language-specific abstraction that safely and conveniently handles it. Examples
+//!   include converting an [`CStrPointer`](string) to a C# `string`, or a [`service`](crate::patterns::service)
+//!   to a Python `class`.
 //!
 //! - The pattern is not supported and will be **omitted, if the pattern was merely an aggregate** of
-//! existing items. Examples include the [`service`](crate::patterns::service) pattern in C which will not
-//! be emitted. However, this will not pose a problem as all constituent types and methods (functions)
-//! are still available as raw bindings.
+//!   existing items. Examples include the [`service`](crate::patterns::service) pattern in C which will not
+//!   be emitted. However, this will not pose a problem as all constituent types and methods (functions)
+//!   are still available as raw bindings.
 //!
 //! - The pattern is not supported and will be **replaced with a fallback type**. Examples include
-//! the [`CStrPointer`](string) which will become a regular `*const char` in C.
+//!   the [`CStrPointer`](string) which will become a regular `*const char` in C.
 //!
 //! In other words, regardless of which pattern was used, the involved methods and types will always
 //! be accessible from any language.
 //!
 //! # Pattern Composition
 //!
-//! Due do a lack of expressiveness in other languages, pattern composition is often limited. Things that work
+//! Due to a lack of expressiveness in other languages, pattern composition is often limited. Things that work
 //! easily in Rust (e.g., a nested `FFISlice<FFIOption<CStrPointer>>`), aren't supported in other languages.
 //! You therefore should rather err on the side of conservatism when designing APIs.
 //!

crates/core/src/patterns/result.rs

@@ -196,10 +196,7 @@ impl FFIErrorEnum {
 /// (and probably gracefully shutdown or restart), as any subsequent call risks causing a
 /// process abort.
 #[allow(unused_variables)]
-pub fn panics_and_errors_to_ffi_enum<E: Debug, FE: FFIError>(f: impl FnOnce() -> Result<(), E>, error_context: &str) -> FE
-where
-    FE: From<E>,
-{
+pub fn panics_and_errors_to_ffi_enum<E: Debug, FE: FFIError + From<E>>(f: impl FnOnce() -> Result<(), E>, error_context: &str) -> FE {
     let result: Result<(), E> = match std::panic::catch_unwind(AssertUnwindSafe(f)) {
         Ok(x) => x,
         Err(e) => {
@@ -221,7 +218,7 @@ where
 /// Extracts a string message from a panic unwind.
 pub fn get_panic_message(pan: &(dyn Any + Send)) -> &str {
     match pan.downcast_ref::<&'static str>() {
-        Some(s) => *s,
+        Some(s) => s,
         None => match pan.downcast_ref::<String>() {
             Some(s) => s,
             None => "Any { .. }",

examples/real_project_layout/core_library_ffi/src/error.rs

@@ -20,10 +20,8 @@ pub enum Error {
 }
 
 impl From<interoptopus::Error> for Error {
-    fn from(x: interoptopus::Error) -> Self {
-        match x {
-            _ => Self::Bad,
-        }
+    fn from(_: interoptopus::Error) -> Self {
+        Self::Bad
     }
 }