internal: suppress non_snake_case lint in [pin_]init!

Changes how `[pin_]init!` handles `InitializerKind::Value` to avoid
creating a local variable that can cause `non_snake_case` lint.

Allows `non_snake_case` lint on local variables generated elsewhere
in `[pin_]init!`.

Since the same warning will be reported by the compiler on the struct
definition, having the extra warning for the generated local variables
is unnecessary and confusing.

Reported-by: Gary Guo <gary@garyguo.net>
Link: #125
Closes: https://lore.kernel.org/rust-for-linux/DGTBJBIVFZ2K.2F1ZEFGY0G7NK@garyguo.net/
Fixes: db96c51 ("add references to previously initialized fields")
Co-developed-by: Gary Guo <gary@garyguo.net>
Signed-off-by: Gary Guo <gary@garyguo.net>
Signed-off-by: Mirko Adzic <adzicmirko97@gmail.com>

Author: Mirko-A

CHANGELOG.md

@@ -41,6 +41,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   check by `#[pin_data]`.
 - `#[pin_data]` no longer produces additional `non_snake_case` warnings if field names
   are not of snake case. Standard field definition warnings are unaffected.
+- `init!` and `pin_init!` no longer produce `non_snake_case` warnings if field names
+  are not of snake case. Warnings on the struct definition are unaffected.
 
 ## [0.0.10] - 2025-08-19
 

internal/src/init.rs

@@ -240,13 +240,26 @@ fn init_fields(
         };
         let init = match kind {
             InitializerKind::Value { ident, value } => {
-                let mut value_ident = ident.clone();
-                let value_prep = value.as_ref().map(|value| &value.1).map(|value| {
-                    // Setting the span of `value_ident` to `value`'s span improves error messages
-                    // when the type of `value` is wrong.
-                    value_ident.set_span(value.span());
-                    quote!(let #value_ident = #value;)
-                });
+                let (value_prep, value_ident) = match value.as_ref() {
+                    None => {
+                        // This is of short-hand syntax, so just use the identifier directly.
+                        (None, ident.clone())
+                    }
+                    Some((_, value)) => {
+                        // We have an expression. Evaluate it to a local variable first, outside
+                        // `unsafe {}` block.
+                        //
+                        // Setting the span of `value_ident` to `value`'s span improves error messages
+                        // when the type of `value` is wrong.
+                        let value_ident = format_ident!("value", span = value.span());
+                        (
+                            Some(quote! {
+                                let #value_ident = #value;
+                            }),
+                            value_ident,
+                        )
+                    }
+                };
                 // Again span for better diagnostics
                 let write = quote_spanned!(ident.span()=> ::core::ptr::write);
                 quote! {
@@ -333,7 +346,9 @@ fn init_fields(
                 };
 
                 #(#cfgs)*
-                #[allow(unused_variables)]
+                // Allow `non_snake_case` since the same warning is going to be reported for
+                // the struct field.
+                #[allow(unused_variables, non_snake_case)]
                 let #ident = #accessor;
             });
             guards.push(guard);