Client Test

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/simple_struct_operation/_simple_struct_operation_output.rs

@@ -224,224 +394,394 @@

     "float",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$double",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$timestamp",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,

     "timestamp",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$enum",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##enum",
     "enum",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredBlob",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "required_blob",
     "requiredBlob",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredBoolean",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "required_boolean",
     "requiredBoolean",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredString",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "required_string",
     "requiredString",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredByte",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "required_byte",
     "requiredByte",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredShort",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "required_short",
     "requiredShort",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredInteger",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "required_integer",
     "requiredInteger",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredLong",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "required_long",
     "requiredLong",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredFloat",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "required_float",
     "requiredFloat",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredDouble",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "required_double",
     "requiredDouble",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredTimestamp",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "required_timestamp",
     "requiredTimestamp",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#SimpleStructOperationOutput$requiredEnum",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SimpleStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "required_enum",
     "requiredEnum",
 ,
 );
 static SIMPLESTRUCTOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SIMPLESTRUCTOPERATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_BLOB,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_BOOLEAN,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_STRING,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_BYTE,

↧ Expand context

         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_SHORT,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_INTEGER,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_LONG,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_FLOAT,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_DOUBLE,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_TIMESTAMP,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_ENUM,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_BLOB,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_BOOLEAN,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_STRING,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_BYTE,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_SHORT,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_INTEGER,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_LONG,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_FLOAT,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_DOUBLE,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_TIMESTAMP,
         &SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_ENUM,
     ],
 );

@@ -457,457 +529,529 @@

↥ Expand context

-457
+        }
-458
+        {
             let val = &self.required_integer;
             ser.write_integer(&SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_INTEGER, *val)?;
-461
+        }
-462
+        {
             let val = &self.required_long;
             ser.write_long(&SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_LONG, *val)?;
-465
+        }
-466
+        {
             let val = &self.required_float;
             ser.write_float(&SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_FLOAT, *val)?;
-469
+        }
-470
+        {
             let val = &self.required_double;
             ser.write_double(&SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_DOUBLE, *val)?;
-473
+        }
-474
+        {
             let val = &self.required_timestamp;
             ser.write_timestamp(&SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_TIMESTAMP, val)?;

-477
+        }
-478
+        {
             let val = &self.required_enum;
             ser.write_string(&SIMPLESTRUCTOPERATIONOUTPUT_MEMBER_REQUIRED_ENUM, val.as_str())?;
-481
+        }
         Ok(())
-483
+    }
-484
+}
 impl SimpleStructOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SIMPLESTRUCTOPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SIMPLESTRUCTOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.blob = Some(deser.read_blob(member)?);
-503
+                }
                 Some(1) => {
                     builder.boolean = Some(deser.read_boolean(member)?);
-506
+                }
                 Some(2) => {
                     builder.string = Some(deser.read_string(member)?);
-509
+                }

↧ Expand context

                 Some(3) => {
                     builder.byte = Some(deser.read_byte(member)?);
-512
+                }
                 Some(4) => {
                     builder.short = Some(deser.read_short(member)?);
-515
+                }
                 Some(5) => {
                     builder.integer = Some(deser.read_integer(member)?);
-518
+                }
                 Some(6) => {
                     builder.long = Some(deser.read_long(member)?);
-521
+                }
                 Some(7) => {
                     builder.float = Some(deser.read_float(member)?);
-524
+                }
                 Some(8) => {
                     builder.double = Some(deser.read_double(member)?);
-527
+                }
                 Some(9) => {
                     builder.timestamp = Some(deser.read_timestamp(member)?);

@@ -541,541 +605,626 @@

↥ Expand context

                     builder.required_string = Some(deser.read_string(member)?);
-542
+                }
                 Some(14) => {
                     builder.required_byte = Some(deser.read_byte(member)?);
-545
+                }
                 Some(15) => {
                     builder.required_short = Some(deser.read_short(member)?);
-548
+                }
                 Some(16) => {
                     builder.required_integer = Some(deser.read_integer(member)?);
-551
+                }
                 Some(17) => {
                     builder.required_long = Some(deser.read_long(member)?);
-554
+                }
                 Some(18) => {
                     builder.required_float = Some(deser.read_float(member)?);
-557
+                }
                 Some(19) => {
                     builder.required_double = Some(deser.read_double(member)?);
-560
+                }

                 Some(20) => {
                     builder.required_timestamp = Some(deser.read_timestamp(member)?);
-563
+                }
                 Some(21) => {
                     builder.required_enum = Some(crate::types::Suit::from(deser.read_string(member)?.as_str()));
-566
+                }
                 _ => {}
-568
+            }
             Ok(())
         })?;
         builder.required_blob = builder.required_blob.or(Some(::aws_smithy_types::Blob::new("")));
         builder.required_boolean = builder.required_boolean.or(Some(false));
         builder.required_string = builder.required_string.or(Some(String::new()));
         builder.required_byte = builder.required_byte.or(Some(0i8));
         builder.required_short = builder.required_short.or(Some(0i16));
         builder.required_integer = builder.required_integer.or(Some(0i32));
         builder.required_long = builder.required_long.or(Some(0i64));
         builder.required_float = builder.required_float.or(Some(0.0f32));
         builder.required_double = builder.required_double.or(Some(0.0f64));
         builder.required_timestamp = builder.required_timestamp.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-584
+    }
-585
+}
 impl SimpleStructOperationOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl SimpleStructOperationOutput {
     /// Creates a new builder-style object to manufacture [`SimpleStructOperationOutput`](crate::operation::simple_struct_operation::SimpleStructOperationOutput).
     pub fn builder() -> crate::operation::simple_struct_operation::builders::SimpleStructOperationOutputBuilder {
         crate::operation::simple_struct_operation::builders::SimpleStructOperationOutputBuilder::default()
-601
+    }
-602
+}
-603
 /// A builder for [`SimpleStructOperationOutput`](crate::operation::simple_struct_operation::SimpleStructOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SimpleStructOperationOutputBuilder {
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) boolean: ::std::option::Option<bool>,
     pub(crate) string: ::std::option::Option<::std::string::String>,
     pub(crate) byte: ::std::option::Option<i8>,
     pub(crate) short: ::std::option::Option<i16>,
     pub(crate) integer: ::std::option::Option<i32>,
     pub(crate) long: ::std::option::Option<i64>,
     pub(crate) float: ::std::option::Option<f32>,
     pub(crate) double: ::std::option::Option<f64>,
     pub(crate) timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) r#enum: ::std::option::Option<crate::types::Suit>,
     pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) required_boolean: ::std::option::Option<bool>,
     pub(crate) required_string: ::std::option::Option<::std::string::String>,
     pub(crate) required_byte: ::std::option::Option<i8>,
     pub(crate) required_short: ::std::option::Option<i16>,
     pub(crate) required_integer: ::std::option::Option<i32>,
     pub(crate) required_long: ::std::option::Option<i64>,
     pub(crate) required_float: ::std::option::Option<f32>,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/single_member_struct_operation.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `SingleMemberStructOperation`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SingleMemberStructOperation;
 impl SingleMemberStructOperation {
     /// Creates a new `SingleMemberStructOperation`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::single_member_struct_operation::SingleMemberStructOperationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::single_member_struct_operation::SingleMemberStructOperationInput,
     ) -> ::std::result::Result<
         crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::single_member_struct_operation::SingleMemberStructOperationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::single_member_struct_operation::SingleMemberStructOperationError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -110,116 +172,179 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "SingleMemberStructOperation",
             "RpcV2CborService",
         ));
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("SingleMemberStructOperation")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(SingleMemberStructOperationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::single_member_struct_operation::SingleMemberStructOperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::single_member_struct_operation::SingleMemberStructOperationError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct SingleMemberStructOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SingleMemberStructOperationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-156
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_single_member_struct_operation::de_single_member_struct_operation_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_single_member_struct_operation::de_single_member_struct_operation_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-163
+    }
-164
+}
 #[derive(Debug)]
 struct SingleMemberStructOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SingleMemberStructOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::single_member_struct_operation::SingleMemberStructOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/single_member_struct_operation/_single_member_struct_operation_input.rs

@@ -23,23 +108,119 @@

↥ Expand context

         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SingleMemberStructOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
 ,
 );
 static SINGLEMEMBERSTRUCTOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SINGLEMEMBERSTRUCTOPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SINGLEMEMBERSTRUCTOPERATIONINPUT_MEMBER_MESSAGE],
 );
 impl SingleMemberStructOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SINGLEMEMBERSTRUCTOPERATIONINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SingleMemberStructOperationInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&SINGLEMEMBERSTRUCTOPERATIONINPUT_MEMBER_MESSAGE, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl SingleMemberStructOperationInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SINGLEMEMBERSTRUCTOPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SINGLEMEMBERSTRUCTOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl SingleMemberStructOperationInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl SingleMemberStructOperationInput {
     /// Creates a new builder-style object to manufacture [`SingleMemberStructOperationInput`](crate::operation::single_member_struct_operation::SingleMemberStructOperationInput).
     pub fn builder() -> crate::operation::single_member_struct_operation::builders::SingleMemberStructOperationInputBuilder {
         crate::operation::single_member_struct_operation::builders::SingleMemberStructOperationInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`SingleMemberStructOperationInput`](crate::operation::single_member_struct_operation::SingleMemberStructOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SingleMemberStructOperationInputBuilder {
     pub(crate) message: ::std::option::Option<::std::string::String>,
-102
+}
 impl SingleMemberStructOperationInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.message = ::std::option::Option::Some(input.into());
         self
-108
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.message = input;
         self
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_message(&self) -> &::std::option::Option<::std::string::String> {
         &self.message
-117
+    }
     /// Consumes the builder and constructs a [`SingleMemberStructOperationInput`](crate::operation::single_member_struct_operation::SingleMemberStructOperationInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/single_member_struct_operation/_single_member_struct_operation_output.rs

@@ -23,23 +106,117 @@

↥ Expand context

         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "SingleMemberStructOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
 ,
 );
 static SINGLEMEMBERSTRUCTOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SINGLEMEMBERSTRUCTOPERATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SINGLEMEMBERSTRUCTOPERATIONOUTPUT_MEMBER_MESSAGE],
 );
 impl SingleMemberStructOperationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SINGLEMEMBERSTRUCTOPERATIONOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SingleMemberStructOperationOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&SINGLEMEMBERSTRUCTOPERATIONOUTPUT_MEMBER_MESSAGE, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl SingleMemberStructOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SINGLEMEMBERSTRUCTOPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SINGLEMEMBERSTRUCTOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl SingleMemberStructOperationOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl SingleMemberStructOperationOutput {
     /// Creates a new builder-style object to manufacture [`SingleMemberStructOperationOutput`](crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput).
     pub fn builder() -> crate::operation::single_member_struct_operation::builders::SingleMemberStructOperationOutputBuilder {
         crate::operation::single_member_struct_operation::builders::SingleMemberStructOperationOutputBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`SingleMemberStructOperationOutput`](crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SingleMemberStructOperationOutputBuilder {
     pub(crate) message: ::std::option::Option<::std::string::String>,
-100
+}
 impl SingleMemberStructOperationOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.message = ::std::option::Option::Some(input.into());
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.message = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_message(&self) -> &::std::option::Option<::std::string::String> {
         &self.message
-115
+    }
     /// Consumes the builder and constructs a [`SingleMemberStructOperationOutput`](crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput).
     pub fn build(self) -> crate::operation::single_member_struct_operation::SingleMemberStructOperationOutput {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingOperation`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperation;
 impl StreamingOperation {
     /// Creates a new `StreamingOperation`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::streaming_operation::StreamingOperationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::streaming_operation::StreamingOperationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_operation::StreamingOperationInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_operation::StreamingOperationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_operation::StreamingOperationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::streaming_operation::StreamingOperationError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::streaming_operation::StreamingOperationOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -125,129 +187,192 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::streaming_operation::StreamingOperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_operation::StreamingOperationError,
             >::new());
-135
         ::std::borrow::Cow::Owned(rcb)
-137
+    }
-138
+}
-139
 #[derive(Debug)]
 struct StreamingOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingOperationResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;

-149
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-153
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation::de_streaming_operation_http_response(response),
         ))
-157
+    }
-158
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_streaming_operation::de_streaming_operation_http_error(
             response.status().as_u16(),
             response.headers(),
             body,
         ))
-171
+    }
-172
+}

↧ Expand context

 #[derive(Debug)]
 struct StreamingOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::streaming_operation::StreamingOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::streaming_operation::StreamingOperationInput,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation/_streaming_operation_input.rs

@@ -15,15 +112,119 @@

↥ Expand context

 static STREAMINGOPERATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationInput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationInput",
 );
 static STREAMINGOPERATIONINPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationInput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STREAMINGOPERATIONINPUT_MEMBER_EVENTS],
 );

 impl StreamingOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONINPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-46
+    }
-47
+}
 impl StreamingOperationInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl StreamingOperationInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationInput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationInput`](crate::operation::streaming_operation::StreamingOperationInput).
     pub fn builder() -> crate::operation::streaming_operation::builders::StreamingOperationInputBuilder {
         crate::operation::streaming_operation::builders::StreamingOperationInputBuilder::default()
-94
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(self) -> crate::operation::streaming_operation::builders::StreamingOperationInputBuilder {
         Self::builder().events(self.events)
-98
+    }
-99
+}

↧ Expand context

-100
 /// A builder for [`StreamingOperationInput`](crate::operation::streaming_operation::StreamingOperationInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationInputBuilder {
     pub(crate) events:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>>,
-107
+}
 impl StreamingOperationInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(
         mut self,
         input: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>,
     ) -> Self {
         self.events = ::std::option::Option::Some(input);
         self
-116
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_events(
         mut self,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation/_streaming_operation_output.rs

@@ -15,15 +112,119 @@

↥ Expand context

 static STREAMINGOPERATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationOutput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationOutput",
 );
 static STREAMINGOPERATIONOUTPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationOutput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STREAMINGOPERATIONOUTPUT_MEMBER_EVENTS],
 );

 impl StreamingOperationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONOUTPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-46
+    }
-47
+}
 impl StreamingOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl StreamingOperationOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationOutput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationOutput`](crate::operation::streaming_operation::StreamingOperationOutput).
     pub fn builder() -> crate::operation::streaming_operation::builders::StreamingOperationOutputBuilder {
         crate::operation::streaming_operation::builders::StreamingOperationOutputBuilder::default()
-94
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(self) -> crate::operation::streaming_operation::builders::StreamingOperationOutputBuilder {
         Self::builder().events(self.events)
-98
+    }
-99
+}

↧ Expand context

-100
 /// A builder for [`StreamingOperationOutput`](crate::operation::streaming_operation::StreamingOperationOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationOutputBuilder {
     pub(crate) events: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>>,
-106
+}
 impl StreamingOperationOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(mut self, input: crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>) -> Self {
         self.events = ::std::option::Option::Some(input);
         self
-112
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_events(
         mut self,
         input: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>>,
     ) -> Self {
         self.events = input;
         self

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_initial_data.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingOperationWithInitialData`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithInitialData;
 impl StreamingOperationWithInitialData {
     /// Creates a new `StreamingOperationWithInitialData`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -125,131 +187,194 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataError,
             >::new());
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct StreamingOperationWithInitialDataResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingOperationWithInitialDataResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;

-151
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-155
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation_with_initial_data::de_streaming_operation_with_initial_data_http_response(response),
         ))
-159
+    }
-160
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation_with_initial_data::de_streaming_operation_with_initial_data_http_error(
                 response.status().as_u16(),
                 response.headers(),
                 body,
             ),
-174
+        )

↧ Expand context

-175
+    }
-176
+}
 #[derive(Debug)]
 struct StreamingOperationWithInitialDataRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationWithInitialDataRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_initial_data/_streaming_operation_with_initial_data_input.rs

@@ -3,3 +137,145 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub struct StreamingOperationWithInitialDataInput {
     #[allow(missing_docs)] // documentation missing in model
     pub initial_data: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub events: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>,
-10
+}
 impl StreamingOperationWithInitialDataInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn initial_data(&self) -> ::std::option::Option<&str> {
         self.initial_data.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(&self) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError> {
         &self.events
-19
+    }
-20
+}
 static STREAMINGOPERATIONWITHINITIALDATAINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialDataInput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationWithInitialDataInput",
 );
 static STREAMINGOPERATIONWITHINITIALDATAINPUT_MEMBER_INITIAL_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialDataInput$initialData",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithInitialDataInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "initial_data",
     "initialData",
 ,
 );
 static STREAMINGOPERATIONWITHINITIALDATAINPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialDataInput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithInitialDataInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONWITHINITIALDATAINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONWITHINITIALDATAINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGOPERATIONWITHINITIALDATAINPUT_MEMBER_INITIAL_DATA,
         &STREAMINGOPERATIONWITHINITIALDATAINPUT_MEMBER_EVENTS,
     ],
 );
 impl StreamingOperationWithInitialDataInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONWITHINITIALDATAINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationWithInitialDataInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.initial_data {
             ser.write_string(&STREAMINGOPERATIONWITHINITIALDATAINPUT_MEMBER_INITIAL_DATA, val)?;
-66
+        }
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONWITHINITIALDATAINPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-68
+    }
-69
+}
 impl StreamingOperationWithInitialDataInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALDATAINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALDATAINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.initial_data = Some(deser.read_string(member)?);
-88
+                }
                 Some(1) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder.initial_data = builder.initial_data.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-103
+    }
-104
+}
 impl StreamingOperationWithInitialDataInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationWithInitialDataInput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialDataInput`](crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput).
     pub fn builder() -> crate::operation::streaming_operation_with_initial_data::builders::StreamingOperationWithInitialDataInputBuilder {
         crate::operation::streaming_operation_with_initial_data::builders::StreamingOperationWithInitialDataInputBuilder::default()
-120
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(
         self,
     ) -> crate::operation::streaming_operation_with_initial_data::builders::StreamingOperationWithInitialDataInputBuilder {
         Self::builder().set_initial_data(self.initial_data).events(self.events)

↧ Expand context

-126
+    }
-127
+}
-128
 /// A builder for [`StreamingOperationWithInitialDataInput`](crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithInitialDataInputBuilder {
     pub(crate) initial_data: ::std::option::Option<::std::string::String>,
     pub(crate) events:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>>,
-136
+}
 impl StreamingOperationWithInitialDataInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn initial_data(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.initial_data = ::std::option::Option::Some(input.into());
         self
-143
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_initial_data(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_initial_data/_streaming_operation_with_initial_data_output.rs

@@ -15,15 +112,119 @@

↥ Expand context

 static STREAMINGOPERATIONWITHINITIALDATAOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialDataOutput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationWithInitialDataOutput",
 );
 static STREAMINGOPERATIONWITHINITIALDATAOUTPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialDataOutput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithInitialDataOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONWITHINITIALDATAOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONWITHINITIALDATAOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STREAMINGOPERATIONWITHINITIALDATAOUTPUT_MEMBER_EVENTS],
 );

 impl StreamingOperationWithInitialDataOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONWITHINITIALDATAOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationWithInitialDataOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONWITHINITIALDATAOUTPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-46
+    }
-47
+}
 impl StreamingOperationWithInitialDataOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALDATAOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALDATAOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl StreamingOperationWithInitialDataOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationWithInitialDataOutput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialDataOutput`](crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataOutput).
     pub fn builder() -> crate::operation::streaming_operation_with_initial_data::builders::StreamingOperationWithInitialDataOutputBuilder {
         crate::operation::streaming_operation_with_initial_data::builders::StreamingOperationWithInitialDataOutputBuilder::default()
-94
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(
         self,
     ) -> crate::operation::streaming_operation_with_initial_data::builders::StreamingOperationWithInitialDataOutputBuilder {
         Self::builder().events(self.events)

↧ Expand context

-100
+    }
-101
+}
-102
 /// A builder for [`StreamingOperationWithInitialDataOutput`](crate::operation::streaming_operation_with_initial_data::StreamingOperationWithInitialDataOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithInitialDataOutputBuilder {
     pub(crate) events: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>>,
-108
+}
 impl StreamingOperationWithInitialDataOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(mut self, input: crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>) -> Self {
         self.events = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_events(
         mut self,
         input: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>>,
     ) -> Self {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_initial_response.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingOperationWithInitialResponse`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithInitialResponse;
 impl StreamingOperationWithInitialResponse {
     /// Creates a new `StreamingOperationWithInitialResponse`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -127,133 +189,196 @@

↥ Expand context

             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseError,
             >::new());
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct StreamingOperationWithInitialResponseResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingOperationWithInitialResponseResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;
-151
         // If this is an error, defer to the non-streaming parser

         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-155
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation_with_initial_response::de_streaming_operation_with_initial_response_http_response(
                 response,
             ),
         ))
-161
+    }
-162
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation_with_initial_response::de_streaming_operation_with_initial_response_http_error(
                 response.status().as_u16(),
                 response.headers(),
                 body,
             ),
-176
+        )

↧ Expand context

-177
+    }
-178
+}
 #[derive(Debug)]
 struct StreamingOperationWithInitialResponseRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationWithInitialResponseRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_initial_response/_streaming_operation_with_initial_response_input.rs

@@ -15,15 +112,119 @@

↥ Expand context

 static STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialResponseInput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationWithInitialResponseInput",
 );
 static STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialResponseInput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithInitialResponseInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_MEMBER_EVENTS],
 );

 impl StreamingOperationWithInitialResponseInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationWithInitialResponseInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-46
+    }
-47
+}
 impl StreamingOperationWithInitialResponseInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALRESPONSEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl StreamingOperationWithInitialResponseInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationWithInitialResponseInput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialResponseInput`](crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput).
     pub fn builder() -> crate::operation::streaming_operation_with_initial_response::builders::StreamingOperationWithInitialResponseInputBuilder {
         crate::operation::streaming_operation_with_initial_response::builders::StreamingOperationWithInitialResponseInputBuilder::default()
-94
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(
         self,
     ) -> crate::operation::streaming_operation_with_initial_response::builders::StreamingOperationWithInitialResponseInputBuilder {
         Self::builder().events(self.events)

↧ Expand context

-100
+    }
-101
+}
-102
 /// A builder for [`StreamingOperationWithInitialResponseInput`](crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithInitialResponseInputBuilder {
     pub(crate) events:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>>,
-109
+}
 impl StreamingOperationWithInitialResponseInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(
         mut self,
         input: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>,
     ) -> Self {
         self.events = ::std::option::Option::Some(input);
         self
-118
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_initial_response/_streaming_operation_with_initial_response_output.rs

@@ -4,4 +139,147 @@

↥ Expand context

 #[derive(::std::fmt::Debug)]
 pub struct StreamingOperationWithInitialResponseOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub response_data: ::std::string::String,
     #[allow(missing_docs)] // documentation missing in model
     pub events: crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>,
-10
+}
 impl StreamingOperationWithInitialResponseOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn response_data(&self) -> &str {
         use std::ops::Deref;
         self.response_data.deref()
-16
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(&self) -> &crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError> {
         &self.events
-20
+    }
-21
+}
 static STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialResponseOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationWithInitialResponseOutput",
 );
 static STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_MEMBER_RESPONSE_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialResponseOutput$responseData",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithInitialResponseOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "response_data",
     "responseData",
 ,
 );
 static STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithInitialResponseOutput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithInitialResponseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_MEMBER_RESPONSE_DATA,
         &STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_MEMBER_EVENTS,
     ],
 );
 impl StreamingOperationWithInitialResponseOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationWithInitialResponseOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-65
+        {
             let val = &self.response_data;
             ser.write_string(&STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_MEMBER_RESPONSE_DATA, val)?;
-68
+        }
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-70
+    }
-71
+}
 impl StreamingOperationWithInitialResponseOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONWITHINITIALRESPONSEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.response_data = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-96
+                }
                 _ => {}
-98
+            }
             Ok(())
         })?;
         builder.response_data = builder.response_data.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-105
+    }
-106
+}
 impl StreamingOperationWithInitialResponseOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationWithInitialResponseOutput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialResponseOutput`](crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseOutput).
     pub fn builder() -> crate::operation::streaming_operation_with_initial_response::builders::StreamingOperationWithInitialResponseOutputBuilder {
         crate::operation::streaming_operation_with_initial_response::builders::StreamingOperationWithInitialResponseOutputBuilder::default()
-122
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(
         self,
     ) -> crate::operation::streaming_operation_with_initial_response::builders::StreamingOperationWithInitialResponseOutputBuilder {
         Self::builder().response_data(self.response_data).events(self.events)

↧ Expand context

-128
+    }
-129
+}
-130
 /// A builder for [`StreamingOperationWithInitialResponseOutput`](crate::operation::streaming_operation_with_initial_response::StreamingOperationWithInitialResponseOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithInitialResponseOutputBuilder {
     pub(crate) response_data: ::std::option::Option<::std::string::String>,
     pub(crate) events: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>>,
-137
+}
 impl StreamingOperationWithInitialResponseOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn response_data(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.response_data = ::std::option::Option::Some(input.into());
         self
-144
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_response_data(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.response_data = input;

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_optional_data.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingOperationWithOptionalData`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithOptionalData;
 impl StreamingOperationWithOptionalData {
     /// Creates a new `StreamingOperationWithOptionalData`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -125,131 +187,194 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataError,
             >::new());
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct StreamingOperationWithOptionalDataResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingOperationWithOptionalDataResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;

-151
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-155
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation_with_optional_data::de_streaming_operation_with_optional_data_http_response(response),
         ))
-159
+    }
-160
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_operation_with_optional_data::de_streaming_operation_with_optional_data_http_error(
                 response.status().as_u16(),
                 response.headers(),
                 body,
             ),
-174
+        )

↧ Expand context

-175
+    }
-176
+}
 #[derive(Debug)]
 struct StreamingOperationWithOptionalDataRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingOperationWithOptionalDataRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_optional_data/_streaming_operation_with_optional_data_input.rs

@@ -3,3 +137,144 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub struct StreamingOperationWithOptionalDataInput {
     #[allow(missing_docs)] // documentation missing in model
     pub optional_data: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub events: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>,
-10
+}
 impl StreamingOperationWithOptionalDataInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn optional_data(&self) -> ::std::option::Option<&str> {
         self.optional_data.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(&self) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError> {
         &self.events
-19
+    }
-20
+}
 static STREAMINGOPERATIONWITHOPTIONALDATAINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithOptionalDataInput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationWithOptionalDataInput",
 );
 static STREAMINGOPERATIONWITHOPTIONALDATAINPUT_MEMBER_OPTIONAL_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithOptionalDataInput$optionalData",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithOptionalDataInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "optional_data",
     "optionalData",
 ,
 );
 static STREAMINGOPERATIONWITHOPTIONALDATAINPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithOptionalDataInput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithOptionalDataInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONWITHOPTIONALDATAINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONWITHOPTIONALDATAINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGOPERATIONWITHOPTIONALDATAINPUT_MEMBER_OPTIONAL_DATA,
         &STREAMINGOPERATIONWITHOPTIONALDATAINPUT_MEMBER_EVENTS,
     ],
 );
 impl StreamingOperationWithOptionalDataInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONWITHOPTIONALDATAINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationWithOptionalDataInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.optional_data {
             ser.write_string(&STREAMINGOPERATIONWITHOPTIONALDATAINPUT_MEMBER_OPTIONAL_DATA, val)?;
-66
+        }
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONWITHOPTIONALDATAINPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-68
+    }
-69
+}
 impl StreamingOperationWithOptionalDataInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONWITHOPTIONALDATAINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONWITHOPTIONALDATAINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.optional_data = Some(deser.read_string(member)?);
-88
+                }
                 Some(1) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-102
+    }
-103
+}
 impl StreamingOperationWithOptionalDataInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationWithOptionalDataInput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationWithOptionalDataInput`](crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput).
     pub fn builder() -> crate::operation::streaming_operation_with_optional_data::builders::StreamingOperationWithOptionalDataInputBuilder {
         crate::operation::streaming_operation_with_optional_data::builders::StreamingOperationWithOptionalDataInputBuilder::default()
-119
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(
         self,
     ) -> crate::operation::streaming_operation_with_optional_data::builders::StreamingOperationWithOptionalDataInputBuilder {
         Self::builder().set_optional_data(self.optional_data).events(self.events)

↧ Expand context

-125
+    }
-126
+}
-127
 /// A builder for [`StreamingOperationWithOptionalDataInput`](crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithOptionalDataInputBuilder {
     pub(crate) optional_data: ::std::option::Option<::std::string::String>,
     pub(crate) events:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::Events, crate::types::error::EventsError>>,
-135
+}
 impl StreamingOperationWithOptionalDataInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn optional_data(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.optional_data = ::std::option::Option::Some(input.into());
         self
-141
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_optional_data(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.optional_data = input;

tmp-codegen-diff/codegen-client-test/rpcv2Cbor_extras/rust-client-codegen/src/operation/streaming_operation_with_optional_data/_streaming_operation_with_optional_data_output.rs

@@ -3,3 +137,144 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub struct StreamingOperationWithOptionalDataOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub optional_response_data: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub events: crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>,
-10
+}
 impl StreamingOperationWithOptionalDataOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn optional_response_data(&self) -> ::std::option::Option<&str> {
         self.optional_response_data.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn events(&self) -> &crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError> {
         &self.events
-19
+    }
-20
+}
 static STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithOptionalDataOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "StreamingOperationWithOptionalDataOutput",
 );
 static STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_MEMBER_OPTIONAL_RESPONSE_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithOptionalDataOutput$optionalResponseData",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithOptionalDataOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "optional_response_data",
     "optionalResponseData",
 ,
 );
 static STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#StreamingOperationWithOptionalDataOutput$events",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "StreamingOperationWithOptionalDataOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "events",
 ,
 );
 static STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_MEMBER_OPTIONAL_RESPONSE_DATA,
         &STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_MEMBER_EVENTS,
     ],
 );
 impl StreamingOperationWithOptionalDataOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingOperationWithOptionalDataOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.optional_response_data {
             ser.write_string(&STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_MEMBER_OPTIONAL_RESPONSE_DATA, val)?;
-66
+        }
--
+        {
             let val = &self.events;
             ser.write_null(&STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_MEMBER_EVENTS)?;
--
+        }
         Ok(())
-68
+    }
-69
+}
 impl StreamingOperationWithOptionalDataOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGOPERATIONWITHOPTIONALDATAOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.optional_response_data = Some(deser.read_string(member)?);
-88
+                }
                 Some(1) => {
                     builder.events = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-102
+    }
-103
+}
 impl StreamingOperationWithOptionalDataOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl StreamingOperationWithOptionalDataOutput {
     /// Creates a new builder-style object to manufacture [`StreamingOperationWithOptionalDataOutput`](crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataOutput).
     pub fn builder() -> crate::operation::streaming_operation_with_optional_data::builders::StreamingOperationWithOptionalDataOutputBuilder {
         crate::operation::streaming_operation_with_optional_data::builders::StreamingOperationWithOptionalDataOutputBuilder::default()
-119
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(
         self,
     ) -> crate::operation::streaming_operation_with_optional_data::builders::StreamingOperationWithOptionalDataOutputBuilder {
         Self::builder()

↧ Expand context

             .set_optional_response_data(self.optional_response_data)
             .events(self.events)
-127
+    }
-128
+}
-129
 /// A builder for [`StreamingOperationWithOptionalDataOutput`](crate::operation::streaming_operation_with_optional_data::StreamingOperationWithOptionalDataOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingOperationWithOptionalDataOutputBuilder {
     pub(crate) optional_response_data: ::std::option::Option<::std::string::String>,
     pub(crate) events: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::Events, crate::types::error::EventsError>>,
-136
+}
 impl StreamingOperationWithOptionalDataOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn optional_response_data(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.optional_response_data = ::std::option::Option::Some(input.into());
         self
-142
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_optional_response_data(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

Client Test

Files changed: