Generate alternate code to overcome clippy warnings

Author: Fahad Zubair

buildSrc/src/main/kotlin/CodegenTestCommon.kt

@@ -291,7 +291,7 @@ fun Project.registerGenerateCargoConfigTomlTask(outputDir: File) {
                 .writeText(
                     """
                     [build]
-                    rustflags = ["--cfg", "aws_sdk_unstable"]
+                    rustflags = ["--deny", "warnings", "--cfg", "aws_sdk_unstable"]
                     """.trimIndent(),
                 )
         }

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerBuilderGenerator.kt

@@ -351,9 +351,21 @@ class ServerBuilderGenerator(
                     if (!constrainedTypeHoldsFinalType(member)) varExpr = "($varExpr).into()"
 
                     if (wrapInMaybeConstrained) {
-                        conditionalBlock("input.map(##[allow(clippy::redundant_closure)] |v| ", ")", conditional = symbol.isOptional()) {
-                            conditionalBlock("Box::new(", ")", conditional = hasBox) {
-                                rust("$maybeConstrainedVariant($varExpr)")
+                        // Temporary fix for `#[allow(clippy::redundant_closure)]` not working in `rustc` version 1.82.
+                        // The issue occurs specifically when we generate code in the form:
+                        // ```rust
+                        // input.map(|v| MaybeConstrained(v))
+                        // ```
+                        // This pattern triggers a clippy warning about redundant closures, even with the allow attribute.
+                        // For this specific pattern, we directly use the constructor function reference.
+                        // Other cases like `Box::new(v)` or `v.into()` are valid closure usages and remain unchanged.
+                        if (symbol.isOptional() && varExpr == "v") {
+                            rust("input.map($maybeConstrainedVariant)")
+                        } else {
+                            conditionalBlock("input.map(##[allow(clippy::redundant_closure)] |v| ", ")", conditional = symbol.isOptional()) {
+                                conditionalBlock("Box::new(", ")", conditional = hasBox) {
+                                    rust("$maybeConstrainedVariant($varExpr)")
+                                }
                             }
                         }
                     } else {

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerBuilderGeneratorCommon.kt

@@ -27,6 +27,7 @@ import software.amazon.smithy.model.shapes.LongShape
 import software.amazon.smithy.model.shapes.MapShape
 import software.amazon.smithy.model.shapes.MemberShape
 import software.amazon.smithy.model.shapes.NumberShape
+import software.amazon.smithy.model.shapes.Shape
 import software.amazon.smithy.model.shapes.ShortShape
 import software.amazon.smithy.model.shapes.StringShape
 import software.amazon.smithy.model.shapes.TimestampShape
@@ -84,8 +85,18 @@ fun generateFallbackCodeToDefaultValue(
     symbolProvider: RustSymbolProvider,
     publicConstrainedTypes: Boolean,
 ) {
-    var defaultValue = defaultValue(model, runtimeConfig, symbolProvider, member)
     val targetShape = model.expectShape(member.target)
+    // Temporary fix for `#[allow(clippy::redundant_closure)]` not working in `rustc` version 1.82.
+    // The issue occurs specifically when we generate code in the form:
+    // ```rust
+    // .unwrap_or_else(HashMap::new())
+    // ```
+    if (isTargetListOrMap(targetShape, member)) {
+        writer.rustTemplate(".unwrap_or_default()")
+        return
+    }
+
+    var defaultValue = defaultValue(model, runtimeConfig, symbolProvider, member)
     val targetSymbol = symbolProvider.toSymbol(targetShape)
     // We need an .into() conversion to create defaults for the server types. A larger scale refactoring could store this information in the
     // symbol, however, retrieving it in this manner works for the moment.
@@ -125,6 +136,22 @@ fun generateFallbackCodeToDefaultValue(
     }
 }
 
+private fun isTargetListOrMap(
+    targetShape: Shape?,
+    member: MemberShape,
+): Boolean {
+    if (targetShape is ListShape) {
+        val node = member.expectTrait<DefaultTrait>().toNode()!!
+        check(node is ArrayNode && node.isEmpty)
+        return true
+    } else if (targetShape is MapShape) {
+        val node = member.expectTrait<DefaultTrait>().toNode()!!
+        check(node is ObjectNode && node.isEmpty)
+        return true
+    }
+    return false
+}
+
 /**
  * Returns a writable to construct a Rust value of the correct type holding the modeled `@default` value on the
  * [member] shape.