Render a Union member of type Unit to an enum variant without inner data

CHANGELOG.next.toml

@@ -502,3 +502,15 @@ in non-serverless environments (e.g. via `hyper`).
 references = ["smithy-rs#2035"]
 meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "server" }
 author = "LukeMathWalker"
+
+[[aws-sdk-rust]]
+message = "The Unit type for a Union member is no longer rendered."
+references = ["smithy-rs#1989"]
+meta = { "breaking" = true, "tada" = false, "bug" = false }
+author = "ysaito1001"
+
+[[smithy-rs]]
+message = "The Unit type for a Union member is no longer rendered."
+references = ["smithy-rs#1989"]
+meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "all" }
+author = "ysaito1001"

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/Instantiator.kt

@@ -50,6 +50,7 @@ import software.amazon.smithy.rust.codegen.core.smithy.rustType
 import software.amazon.smithy.rust.codegen.core.util.dq
 import software.amazon.smithy.rust.codegen.core.util.expectMember
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
+import software.amazon.smithy.rust.codegen.core.util.isTargetUnit
 import software.amazon.smithy.rust.codegen.core.util.letIf
 
 /**
@@ -258,8 +259,10 @@ open class Instantiator(
         val member = shape.expectMember(memberName)
         writer.rust("#T::${symbolProvider.toMemberName(member)}", unionSymbol)
         // Unions should specify exactly one member.
-        writer.withBlock("(", ")") {
-            renderMember(this, member, variant.second, ctx)
+        if (!member.isTargetUnit()) {
+            writer.withBlock("(", ")") {
+                renderMember(this, member, variant.second, ctx)
+            }
         }
     }
 

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/UnionGenerator.kt

@@ -5,6 +5,7 @@
 
 package software.amazon.smithy.rust.codegen.core.smithy.generators
 
+import software.amazon.smithy.codegen.core.Symbol
 import software.amazon.smithy.codegen.core.SymbolProvider
 import software.amazon.smithy.model.Model
 import software.amazon.smithy.model.shapes.MemberShape
@@ -19,6 +20,7 @@ import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
 import software.amazon.smithy.rust.codegen.core.smithy.CodegenTarget
 import software.amazon.smithy.rust.codegen.core.smithy.expectRustMetadata
 import software.amazon.smithy.rust.codegen.core.smithy.renamedFrom
+import software.amazon.smithy.rust.codegen.core.util.isTargetUnit
 import software.amazon.smithy.rust.codegen.core.util.toSnakeCase
 
 fun CodegenTarget.renderUnknownVariant() = when (this) {
@@ -49,16 +51,18 @@ class UnionGenerator(
     private val sortedMembers: List<MemberShape> = shape.allMembers.values.sortedBy { symbolProvider.toMemberName(it) }
 
     fun render() {
-        renderUnion()
-    }
-
-    private fun renderUnion() {
         writer.documentShape(shape, model)
         writer.deprecatedShape(shape)
 
         val unionSymbol = symbolProvider.toSymbol(shape)
         val containerMeta = unionSymbol.expectRustMetadata()
         containerMeta.render(writer)
+
+        renderUnion(unionSymbol)
+        renderImplBlock(unionSymbol)
+    }
+
+    private fun renderUnion(unionSymbol: Symbol) {
         writer.rustBlock("enum ${unionSymbol.name}") {
             sortedMembers.forEach { member ->
                 val memberSymbol = symbolProvider.toSymbol(member)
@@ -67,7 +71,7 @@ class UnionGenerator(
                 documentShape(member, model, note = note)
                 deprecatedShape(member)
                 memberSymbol.expectRustMetadata().renderAttributes(this)
-                write("${symbolProvider.toMemberName(member)}(#T),", symbolProvider.toSymbol(member))
+                writer.renderVariant(symbolProvider, member, memberSymbol)
             }
             if (renderUnknownVariant) {
                 docs("""The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.""")
@@ -82,6 +86,9 @@ class UnionGenerator(
                 rust("Unknown,")
             }
         }
+    }
+
+    private fun renderImplBlock(unionSymbol: Symbol) {
         writer.rustBlock("impl ${unionSymbol.name}") {
             sortedMembers.forEach { member ->
                 val memberSymbol = symbolProvider.toSymbol(member)
@@ -91,11 +98,7 @@ class UnionGenerator(
                 if (sortedMembers.size == 1) {
                     Attribute.Custom("allow(irrefutable_let_patterns)").render(this)
                 }
-                rust("/// Tries to convert the enum instance into [`$variantName`](#T::$variantName), extracting the inner #D.", unionSymbol, memberSymbol)
-                rust("/// Returns `Err(&Self)` if it can't be converted.")
-                rustBlock("pub fn as_$funcNamePart(&self) -> std::result::Result<&#T, &Self>", memberSymbol) {
-                    rust("if let ${unionSymbol.name}::$variantName(val) = &self { Ok(val) } else { Err(self) }")
-                }
+                writer.renderAsVariant(member, variantName, funcNamePart, unionSymbol, memberSymbol)
                 rust("/// Returns true if this is a [`$variantName`](#T::$variantName).", unionSymbol)
                 rustBlock("pub fn is_$funcNamePart(&self) -> bool") {
                     rust("self.as_$funcNamePart().is_ok()")
@@ -114,7 +117,44 @@ class UnionGenerator(
         const val UnknownVariantName = "Unknown"
     }
 }
+
 fun unknownVariantError(union: String) =
     "Cannot serialize `$union::${UnionGenerator.UnknownVariantName}` for the request. " +
         "The `Unknown` variant is intended for responses only. " +
         "It occurs when an outdated client is used after a new enum variant was added on the server side."
+
+private fun RustWriter.renderVariant(symbolProvider: SymbolProvider, member: MemberShape, memberSymbol: Symbol) {
+    if (member.isTargetUnit()) {
+        write("${symbolProvider.toMemberName(member)},")
+    } else {
+        write("${symbolProvider.toMemberName(member)}(#T),", memberSymbol)
+    }
+}
+
+private fun RustWriter.renderAsVariant(
+    member: MemberShape,
+    variantName: String,
+    funcNamePart: String,
+    unionSymbol: Symbol,
+    memberSymbol: Symbol,
+) {
+    if (member.isTargetUnit()) {
+        rust(
+            "/// Tries to convert the enum instance into [`$variantName`], extracting the inner `()`.",
+        )
+        rust("/// Returns `Err(&Self)` if it can't be converted.")
+        rustBlock("pub fn as_$funcNamePart(&self) -> std::result::Result<(), &Self>") {
+            rust("if let ${unionSymbol.name}::$variantName = &self { Ok(()) } else { Err(self) }")
+        }
+    } else {
+        rust(
+            "/// Tries to convert the enum instance into [`$variantName`](#T::$variantName), extracting the inner #D.",
+            unionSymbol,
+            memberSymbol,
+        )
+        rust("/// Returns `Err(&Self)` if it can't be converted.")
+        rustBlock("pub fn as_$funcNamePart(&self) -> std::result::Result<&#T, &Self>", memberSymbol) {
+            rust("if let ${unionSymbol.name}::$variantName(val) = &self { Ok(val) } else { Err(self) }")
+        }
+    }
+}

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/JsonParserGenerator.kt

@@ -54,6 +54,7 @@ import software.amazon.smithy.rust.codegen.core.util.PANIC
 import software.amazon.smithy.rust.codegen.core.util.dq
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
 import software.amazon.smithy.rust.codegen.core.util.inputShape
+import software.amazon.smithy.rust.codegen.core.util.isTargetUnit
 import software.amazon.smithy.rust.codegen.core.util.outputShape
 import software.amazon.smithy.utils.StringUtils
 
@@ -311,6 +312,7 @@ class JsonParserGenerator(
                         rust("#T::from(u.as_ref())", symbolProvider.toSymbol(target))
                     }
                 }
+
                 else -> rust("u.into_owned()")
             }
         }
@@ -510,9 +512,19 @@ class JsonParserGenerator(
                                 for (member in shape.members()) {
                                     val variantName = symbolProvider.toMemberName(member)
                                     rustBlock("${jsonName(member).dq()} =>") {
-                                        withBlock("Some(#T::$variantName(", "))", returnSymbolToParse.symbol) {
-                                            deserializeMember(member)
-                                            unwrapOrDefaultOrError(member)
+                                        if (member.isTargetUnit()) {
+                                            rustTemplate(
+                                                """
+                                                #{skip_value}(tokens)?;
+                                                Some(#{Union}::$variantName)
+                                                """,
+                                                "Union" to returnSymbolToParse.symbol, *codegenScope,
+                                            )
+                                        } else {
+                                            withBlock("Some(#T::$variantName(", "))", returnSymbolToParse.symbol) {
+                                                deserializeMember(member)
+                                                unwrapOrDefaultOrError(member)
+                                            }
                                         }
                                     }
                                 }

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

@@ -51,6 +51,7 @@ import software.amazon.smithy.rust.codegen.core.smithy.traits.SyntheticOutputTra
 import software.amazon.smithy.rust.codegen.core.util.dq
 import software.amazon.smithy.rust.codegen.core.util.expectTrait
 import software.amazon.smithy.rust.codegen.core.util.inputShape
+import software.amazon.smithy.rust.codegen.core.util.isTargetUnit
 import software.amazon.smithy.rust.codegen.core.util.outputShape
 
 /**
@@ -447,9 +448,14 @@ class JsonSerializerGenerator(
 
     private fun RustWriter.jsonObjectWriter(context: MemberContext, inner: RustWriter.(String) -> Unit) {
         safeName("object").also { objectName ->
-            rust("let mut $objectName = ${context.writerExpression}.start_object();")
-            inner(objectName)
-            rust("$objectName.finish();")
+            if (context.shape.isTargetUnit()) {
+                rust("let $objectName = ${context.writerExpression}.start_object();")
+                rust("$objectName.finish();")
+            } else {
+                rust("let mut $objectName = ${context.writerExpression}.start_object();")
+                inner(objectName)
+                rust("$objectName.finish();")
+            }
         }
     }
 
@@ -489,8 +495,15 @@ class JsonSerializerGenerator(
                 rustBlock("match input") {
                     for (member in context.shape.members()) {
                         val variantName = symbolProvider.toMemberName(member)
-                        withBlock("#T::$variantName(inner) => {", "},", unionSymbol) {
-                            serializeMember(MemberContext.unionMember(context, "inner", member, jsonName))
+
+                        if (member.isTargetUnit()) {
+                            withBlock("#T::$variantName => {", "},", unionSymbol) {
+                                serializeMember(MemberContext.unionMember(context, "", member, jsonName))
+                            }
+                        } else {
+                            withBlock("#T::$variantName(inner) => {", "},", unionSymbol) {
+                                serializeMember(MemberContext.unionMember(context, "inner", member, jsonName))
+                            }
                         }
                     }
                     if (codegenTarget.renderUnknownVariant()) {

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

@@ -43,6 +43,7 @@ import software.amazon.smithy.rust.codegen.core.util.dq
 import software.amazon.smithy.rust.codegen.core.util.getTrait
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
 import software.amazon.smithy.rust.codegen.core.util.inputShape
+import software.amazon.smithy.rust.codegen.core.util.isTargetUnit
 import software.amazon.smithy.rust.codegen.core.util.orNull
 
 abstract class QuerySerializerGenerator(codegenContext: CodegenContext) : StructuredDataSerializerGenerator {
@@ -312,14 +313,20 @@ abstract class QuerySerializerGenerator(codegenContext: CodegenContext) : Struct
                 rustBlock("match input") {
                     for (member in context.shape.members()) {
                         val variantName = symbolProvider.toMemberName(member)
-                        withBlock("#T::$variantName(inner) => {", "},", unionSymbol) {
-                            serializeMember(
-                                MemberContext.unionMember(
-                                    context.copy(writerExpression = "writer"),
-                                    "inner",
-                                    member,
-                                ),
-                            )
+                        if (member.isTargetUnit()) {
+                            withBlock("#T::$variantName => {", "},", unionSymbol) {
+                                serializeMember(MemberContext.unionMember(context.copy(writerExpression = "writer"), "", member))
+                            }
+                        } else {
+                            withBlock("#T::$variantName(inner) => {", "},", unionSymbol) {
+                                serializeMember(
+                                    MemberContext.unionMember(
+                                        context.copy(writerExpression = "writer"),
+                                        "inner",
+                                        member,
+                                    ),
+                                )
+                            }
                         }
                     }
                     if (target.renderUnknownVariant()) {

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/util/Smithy.kt

@@ -64,6 +64,12 @@ fun MemberShape.isOutputEventStream(model: Model): Boolean {
     return isEventStream(model) && model.expectShape(container).hasTrait<SyntheticOutputTrait>()
 }
 
+private val unitShapeId = ShapeId.from("smithy.api#Unit")
+
+fun MemberShape.isTargetUnit(): Boolean {
+    return this.target == unitShapeId
+}
+
 fun Shape.hasEventStreamMember(model: Model): Boolean {
     return members().any { it.isEventStream(model) }
 }

codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/UnionGeneratorTest.kt

@@ -125,6 +125,17 @@ class UnionGeneratorTest {
         project.compileAndTest()
     }
 
+    @Test
+    fun `unit types should not appear in generated enum`() {
+        val writer = generateUnion("union MyUnion { a: Unit, b: String }", unknownVariant = true)
+        writer.compileAndTest(
+            """
+            let a = MyUnion::A;
+            assert_eq!(Ok(()), a.as_a());
+            """,
+        )
+    }
+
     private fun generateUnion(modelSmithy: String, unionName: String = "MyUnion", unknownVariant: Boolean = true): RustWriter {
         val model = "namespace test\n$modelSmithy".asSmithyModel()
         val provider: SymbolProvider = testSymbolProvider(model)