Try different protocols against union in question (#4333)

## Motivation and Context
Addresses unused variable warnings identified in #4306. While #4306 fixed XmlBindingTraitSerializerGenerator, it noted that QuerySerializerGenerator contained the same bug when handling union variants with empty structs. 

This PR completes the fix for RestXml and AwsQuery protocols. The issue was discovered in S3Control's ObjectEncryptionFilter where builds with -D warnings were failing.

## Description
Modified `QuerySerializerGenerator` to prefix unused variables with
underscore for empty struct variants:

- Added `isEmptyStruct()` to detect empty structures
- Use `_inner` for empty structs, `inner` for non-empty structs
- No changes to JsonSerializerGenerator or CborSerializerGenerator (as these are not affected)

## Testing
Added tests for RestXml, AwsQuery, and RestJson (documents immunity)
Tests enforce `-D warnings` via `clientIntegrationTest`
Verified S3Control compiles cleanly with `RUSTFLAGS="-D warnings"`

<!---## Checklist
If a checkbox below is not applicable, then please DELETE it rather than
leaving it unchecked -->
<!---- [ ] [x] For changes to the smithy-rs codegen or runtime crates, I
have created a changelog entry Markdown file in the .changelog
directory, specifying "client," "server," or both in the applies_to
key.-->
----

_By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice._

---------

Co-authored-by: ysaito1001 <awsaito@amazon.com>

Author: vcjana

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

@@ -34,8 +34,50 @@ class AwsQueryTest {
         }
         """.asSmithyModel()
 
+    private val inputUnionWithEmptyStructure =
+        """
+        namespace test
+        use aws.protocols#awsQuery
+
+        @awsQuery
+        @xmlNamespace(uri: "https://example.com/")
+        service TestService {
+            version: "2019-12-16",
+            operations: [TestOp]
+        }
+
+        operation TestOp {
+            input: TestInput
+        }
+
+        structure TestInput {
+            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()
+
     @Test
     fun `generate an aws query service that compiles`() {
         clientIntegrationTest(model) { _, _ -> }
     }
+
+    @Test
+    fun `union with empty struct generates warning-free code`() {
+        // This test will fail with unused variable warnings if the fix is not applied
+        // clientIntegrationTest enforces -D warnings via codegenIntegrationTest
+        clientIntegrationTest(inputUnionWithEmptyStructure) { _, _ -> }
+    }
 }

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

@@ -39,8 +39,54 @@ internal class RestJsonTest {
         }
         """.asSmithyModel()
 
+    private val inputUnionWithEmptyStructure =
+        """
+        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
+        }
+
+        structure TestInput {
+            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()
+
     @Test
     fun `generate a rest json service that compiles`() {
         clientIntegrationTest(model) { _, _ -> }
     }
+
+    @Test
+    fun `union with empty struct always uses inner variable`() {
+        // 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(inputUnionWithEmptyStructure) { _, _ -> }
+    }
 }

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

@@ -83,8 +83,51 @@ internal class RestXmlTest {
 
         """.asSmithyModel()
 
+    private val inputUnionWithEmptyStructure =
+        """
+        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
+        }
+
+        structure TestInput {
+            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()
+
     @Test
     fun `generate a rest xml service that compiles`() {
         clientIntegrationTest(model) { _, _ -> }
     }
+
+    @Test
+    fun `union with empty struct generates warning-free code`() {
+        // This test will fail with unused variable warnings if the fix is not applied
+        // clientIntegrationTest enforces -D warnings via codegenIntegrationTest
+        clientIntegrationTest(inputUnionWithEmptyStructure) { _, _ -> }
+    }
 }

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

@@ -345,29 +345,51 @@ 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)
+
+        // Check if any union member uses the writer (non-empty structs)
+        val hasNonEmptyMember =
+            context.shape.members().any { member ->
+                !member.isTargetUnit() && !isEmptyStruct(model.expectShape(member.target))
+            }
+        val writerVarName = if (hasNonEmptyMember) "writer" else "_writer"
+
         val unionSerializer =
             protocolFunctions.serializeFn(context.shape) { fnName ->
                 Attribute.AllowUnusedMut.render(this)
                 rustBlockTemplate(
-                    "pub fn $fnName(mut writer: #{QueryValueWriter}, input: &#{Input}) -> #{Result}<(), #{Error}>",
+                    "pub fn $fnName(mut $writerVarName: #{QueryValueWriter}, input: &#{Input}) -> #{Result}<(), #{Error}>",
                     "Input" to unionSymbol,
                     *codegenScope,
                 ) {
                     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",
+                                        context.copy(writerExpression = writerVarName),
+                                        innerVarName,
                                         member,
                                     ),
                                 )