Add send_with method to fluent builders

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/client/FluentClientGenerator.kt

@@ -352,6 +352,8 @@ class FluentClientGenerator(
         ) {
             val outputType = symbolProvider.toSymbol(operation.outputShape(model))
             val errorType = symbolProvider.symbolForOperationError(operation)
+            val inputBuilderType = symbolProvider.symbolForBuilder(input)
+            val fnName = clientOperationFnName(operation, symbolProvider)
 
             rust("/// Creates a new `${operationSymbol.name}`.")
             withBlockTemplate(
@@ -370,6 +372,43 @@ class FluentClientGenerator(
                     }
                 }
             }
+
+            // this fixes this error
+            //  error[E0592]: duplicate definitions with name `set_fields`
+            //     --> sdk/connectcases/src/operation/update_case/builders.rs:115:5
+            //      |
+            //  78  | /     pub fn set_fields(
+            //  79  | |         mut self,
+            //  80  | |         data: crate::operation::update_case::builders::UpdateCaseInputBuilder,
+            //  81  | |     ) -> Self {
+            //      | |_____________- other definition for `set_fields`
+            //  ...
+            //  115 | /     pub fn set_fields(
+            //  116 | |         mut self,
+            //  117 | |         input: std::option::Option<std::vec::Vec<crate::types::FieldValue>>,
+            //  118 | |     ) -> Self {
+            //      | |_____________^ duplicate definitions for `set_fields`
+            if (inputBuilderType.toString().endsWith("Builder")) {
+                rustTemplate(
+                    """
+                    ##[#{AwsSdkUnstableAttribute}]
+                    /// This function replaces the parameter with new one.
+                    /// It is useful when you want to replace the existing data with de-serialized data.
+                    /// ```compile_fail
+                    /// let result_future = async {
+                    ///     let deserialized_parameters: $inputBuilderType  = serde_json::from_str(&json_string).unwrap();
+                    ///     client.$fnName().set_fields(&deserialized_parameters).send().await
+                    /// };
+                    /// ```
+                    pub fn set_fields(mut self, data: $inputBuilderType) -> Self {
+                        self.inner = data;
+                        self
+                    }
+                    """,
+                    "AwsSdkUnstableAttribute" to Attribute.AwsSdkUnstableAttribute.inner,
+                )
+            }
+
             if (smithyRuntimeMode.generateMiddleware) {
                 val middlewareScope = arrayOf(
                     *preludeScope,

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/CargoDependency.kt

@@ -16,6 +16,7 @@ import java.nio.file.Path
 sealed class DependencyScope {
     object Dev : DependencyScope()
     object Compile : DependencyScope()
+    object CfgUnstable : DependencyScope()
     object Build : DependencyScope()
 }
 
@@ -277,5 +278,8 @@ data class CargoDependency(
         fun smithyRuntimeApi(runtimeConfig: RuntimeConfig) = runtimeConfig.smithyRuntimeCrate("smithy-runtime-api")
         fun smithyTypes(runtimeConfig: RuntimeConfig) = runtimeConfig.smithyRuntimeCrate("smithy-types")
         fun smithyXml(runtimeConfig: RuntimeConfig) = runtimeConfig.smithyRuntimeCrate("smithy-xml")
+
+        // behind feature-gate
+        val Serde = CargoDependency("serde", CratesIo("1.0"), features = setOf("derive"), scope = DependencyScope.CfgUnstable)
     }
 }

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/rustlang/RustType.kt

@@ -475,6 +475,23 @@ class Attribute(val inner: Writable, val isDeriveHelper: Boolean = false) {
         }
     }
 
+    // These were supposed to be a part of companion object but we decided to move it out to here to avoid NPE
+    // You can find the discussion here.
+    // https://github.com/awslabs/smithy-rs/discussions/2248
+    public fun SerdeSerialize(): Attribute {
+        return Attribute(cfgAttr(all(writable("aws_sdk_unstable"), feature("serde-serialize")), derive(RuntimeType.SerdeSerialize)))
+    }
+    public fun SerdeDeserialize(): Attribute {
+        return Attribute(cfgAttr(all(writable("aws_sdk_unstable"), feature("serde-deserialize")), derive(RuntimeType.SerdeDeserialize)))
+    }
+    public fun SerdeSkip(): Attribute {
+        return Attribute(cfgAttr(all(writable("aws_sdk_unstable"), any(feature("serde-serialize"), feature("serde-deserialize"))), serde("skip")))
+    }
+
+    public fun SerdeSerializeOrDeserialize(): Attribute {
+        return Attribute(cfg(all(writable("aws_sdk_unstable"), any(feature("serde-serialize"), feature("serde-deserialize")))))
+    }
+
     companion object {
         val AllowClippyBoxedLocal = Attribute(allow("clippy::boxed_local"))
         val AllowClippyLetAndReturn = Attribute(allow("clippy::let_and_return"))
@@ -504,6 +521,7 @@ class Attribute(val inner: Writable, val isDeriveHelper: Boolean = false) {
 
         val Test = Attribute("test")
         val TokioTest = Attribute(RuntimeType.Tokio.resolve("test").writable)
+        val AwsSdkUnstableAttribute = Attribute(cfg("aws_sdk_unstable"))
 
         /**
          * [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute)
@@ -532,10 +550,12 @@ class Attribute(val inner: Writable, val isDeriveHelper: Boolean = false) {
         }
 
         fun all(vararg attrMacros: Writable): Writable = macroWithArgs("all", *attrMacros)
+        fun cfgAttr(vararg attrMacros: Writable): Writable = macroWithArgs("cfg_attr", *attrMacros)
 
         fun allow(lints: Collection<String>): Writable = macroWithArgs("allow", *lints.toTypedArray())
         fun allow(vararg lints: String): Writable = macroWithArgs("allow", *lints)
         fun deny(vararg lints: String): Writable = macroWithArgs("deny", *lints)
+        fun serde(vararg lints: String): Writable = macroWithArgs("serde", *lints)
         fun any(vararg attrMacros: Writable): Writable = macroWithArgs("any", *attrMacros)
         fun cfg(vararg attrMacros: Writable): Writable = macroWithArgs("cfg", *attrMacros)
         fun cfg(vararg attrMacros: String): Writable = macroWithArgs("cfg", *attrMacros)

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

@@ -301,6 +301,11 @@ data class RuntimeType(val path: String, val dependency: RustDependency? = null)
         val ConstrainedTrait = RuntimeType("crate::constrained::Constrained", InlineDependency.constrained())
         val MaybeConstrained = RuntimeType("crate::constrained::MaybeConstrained", InlineDependency.constrained())
 
+        // serde types. Gated behind `CfgUnstable`.
+        val Serde = CargoDependency.Serde.toType()
+        val SerdeSerialize = Serde.resolve("Serialize")
+        val SerdeDeserialize = Serde.resolve("Deserialize")
+
         // smithy runtime types
         fun smithyAsync(runtimeConfig: RuntimeConfig) = CargoDependency.smithyAsync(runtimeConfig).toType()
         fun smithyChecksums(runtimeConfig: RuntimeConfig) = CargoDependency.smithyChecksums(runtimeConfig).toType()