Fix unused variable warnings in QuerySerializerGenerator for unions with empty structs

- Add isEmptyStruct() helper to detect empty struct shapes
- Use _inner for empty structs to avoid unused variable warnings
- Use inner for non-empty structs where variable is used
- Add comprehensive tests for RestXml, AwsQuery, and RestJson protocols
- Tests enforce -D warnings via clientIntegrationTest

Author: vcjana

codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/AwsQueryTest.kt

@@ -44,4 +44,51 @@ class AwsQueryTest {
     fun `generate an aws query service that compiles`() {
         clientIntegrationTest(model) { _, _ -> }
     }
+
+    @Test
+    fun `union with empty struct generates warning-free code`() {
+        val modelWithEmptyStruct =
+            """
+            namespace test
+            use aws.protocols#awsQuery
+
+            @awsQuery
+            @xmlNamespace(uri: "https://example.com/")
+            service TestService {
+                version: "2019-12-16",
+                operations: [TestOp]
+            }
+
+            operation TestOp {
+                input: TestInput,
+                output: TestOutput
+            }
+
+            structure TestInput {
+                testUnion: TestUnion
+            }
+
+            structure TestOutput {
+                testUnion: TestUnion
+            }
+
+            union TestUnion {
+                // Empty struct - should generate _inner to avoid unused variable warning
+                emptyStruct: EmptyStruct,
+
+                // Normal struct - should generate inner (without underscore)
+                normalStruct: NormalStruct
+            }
+
+            structure EmptyStruct {}
+
+            structure NormalStruct {
+                value: String
+            }
+            """.asSmithyModel()
+
+        // This test will fail with unused variable warnings if the fix is not applied
+        // clientIntegrationTest enforces -D warnings via codegenIntegrationTest
+        clientIntegrationTest(modelWithEmptyStruct) { _, _ -> }
+    }
 }

codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/RestJsonTest.kt

@@ -45,4 +45,55 @@ internal class RestJsonTest {
     fun `generate a rest json service that compiles`() {
         clientIntegrationTest(model) { _, _ -> }
     }
+
+    @Test
+    fun `union with empty struct always uses inner variable`() {
+        val modelWithEmptyStruct =
+            """
+            namespace test
+            use aws.protocols#restJson1
+            use aws.api#service
+
+            @service(sdkId: "Rest Json Empty Struct")
+            @restJson1
+            service RestJsonEmptyStruct {
+                version: "2019-12-16",
+                operations: [TestOp]
+            }
+
+            @http(uri: "/test", method: "POST")
+            operation TestOp {
+                input: TestInput,
+                output: TestOutput
+            }
+
+            structure TestInput {
+                testUnion: TestUnion
+            }
+
+            structure TestOutput {
+                testUnion: TestUnion
+            }
+
+            union TestUnion {
+                // Empty struct - RestJson ALWAYS uses inner variable, no warning
+                emptyStruct: EmptyStruct,
+
+                // Normal struct - RestJson uses inner variable
+                normalStruct: NormalStruct
+            }
+
+            structure EmptyStruct {}
+
+            structure NormalStruct {
+                value: String
+            }
+            """.asSmithyModel()
+
+        // This test documents that RestJson protocol is immune to unused variable issues.
+        // Unlike RestXml/AwsQuery, RestJson serializers always reference the inner variable
+        // even for empty structs, so no underscore prefix is needed.
+        // This test passes without any code changes, proving RestJson immunity.
+        clientIntegrationTest(modelWithEmptyStruct) { _, _ -> }
+    }
 }

codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/protocols/RestXmlTest.kt

@@ -48,4 +48,53 @@ internal class RestXmlTest {
     fun `generate a rest xml service that compiles`() {
         clientIntegrationTest(model) { _, _ -> }
     }
+
+    @Test
+    fun `union with empty struct generates warning-free code`() {
+        val modelWithEmptyStruct =
+            """
+            namespace test
+            use aws.protocols#restXml
+            use aws.api#service
+
+            @service(sdkId: "Rest XML Empty Struct")
+            @restXml
+            service RestXmlEmptyStruct {
+                version: "2019-12-16",
+                operations: [TestOp]
+            }
+
+            @http(uri: "/test", method: "POST")
+            operation TestOp {
+                input: TestInput,
+                output: TestOutput
+            }
+
+            structure TestInput {
+                testUnion: TestUnion
+            }
+
+            structure TestOutput {
+                testUnion: TestUnion
+            }
+
+            union TestUnion {
+                // Empty struct - should generate _inner to avoid unused variable warning
+                emptyStruct: EmptyStruct,
+
+                // Normal struct - should generate inner (without underscore)
+                normalStruct: NormalStruct
+            }
+
+            structure EmptyStruct {}
+
+            structure NormalStruct {
+                value: String
+            }
+            """.asSmithyModel()
+
+        // This test will fail with unused variable warnings if the fix is not applied
+        // clientIntegrationTest enforces -D warnings via codegenIntegrationTest
+        clientIntegrationTest(modelWithEmptyStruct) { _, _ -> }
+    }
 }

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/serialize/QuerySerializerGenerator.kt

@@ -345,6 +345,16 @@ abstract class QuerySerializerGenerator(private val codegenContext: CodegenConte
         }
     }
 
+    /**
+     * Determines if a struct shape is empty (has no members).
+     * Empty structs result in unused variables in union match arms since the inner value is never referenced.
+     */
+    private fun isEmptyStruct(shape: Shape): Boolean =
+        when (shape) {
+            is StructureShape -> shape.members().isEmpty()
+            else -> false
+        }
+
     private fun RustWriter.serializeUnion(context: Context<UnionShape>) {
         val unionSymbol = symbolProvider.toSymbol(context.shape)
         val unionSerializer =
@@ -357,17 +367,21 @@ abstract class QuerySerializerGenerator(private val codegenContext: CodegenConte
                 ) {
                     rustBlock("match input") {
                         for (member in context.shape.members()) {
+                            val targetShape = model.expectShape(member.target)
+                            // Use underscore prefix for empty structs to avoid unused variable warnings
+                            val innerVarName = if (isEmptyStruct(targetShape)) "_inner" else "inner"
+
                             val variantName =
                                 if (member.isTargetUnit()) {
                                     "${symbolProvider.toMemberName(member)}"
                                 } else {
-                                    "${symbolProvider.toMemberName(member)}(inner)"
+                                    "${symbolProvider.toMemberName(member)}($innerVarName)"
                                 }
                             withBlock("#T::$variantName => {", "},", unionSymbol) {
                                 serializeMember(
                                     MemberContext.unionMember(
                                         context.copy(writerExpression = "writer"),
-                                        "inner",
+                                        innerVarName,
                                         member,
                                     ),
                                 )