Fix XML union serialization for empty struct members

When building tests, discovered that serializeUnion was using incorrect
variable name for empty struct members. The pattern match correctly used
'_inner' but serializeMember was called with 'inner', causing compilation
errors. Fixed by passing the correct variable name based on whether the
struct is empty.

Author: vcjana

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

@@ -40,53 +40,53 @@ class AwsQueryTest {
         }
         """.asSmithyModel()
 
+    private 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()
+
     @Test
     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

@@ -11,7 +11,7 @@ import software.amazon.smithy.rust.codegen.core.testutil.asSmithyModel
 
 internal class RestJsonTest {
     val model =
-        """
+            """
         namespace test
         use aws.protocols#restJson1
         use aws.api#service
@@ -41,55 +41,55 @@ internal class RestJsonTest {
         }
         """.asSmithyModel()
 
+    private 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()
+
     @Test
     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.

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

@@ -44,55 +44,55 @@ internal class RestXmlTest {
         }
         """.asSmithyModel()
 
+    private 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()
+
     @Test
     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) { _, _ -> }