Client Test

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/sparse_json_maps/_sparse_json_maps_output.rs

@@ -30,30 +130,130 @@

     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<bool>>> {
         self.sparse_boolean_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_string_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>> {
         self.sparse_string_map.as_ref()
-39
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn sparse_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::vec::Vec<::std::string::String>>>>
-44
+    {
         self.sparse_set_map.as_ref()
-46
+    }
-47
+}
 static SPARSEJSONMAPSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#SparseJsonMapsOutput",

     "aws.protocoltests.restjson.synthetic",
     "SparseJsonMapsOutput",
 );
 static SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#SparseJsonMapsOutput$sparseStructMap",
         "aws.protocoltests.restjson.synthetic",
         "SparseJsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_struct_map",
     "sparseStructMap",
 ,
 );
 static SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#SparseJsonMapsOutput$sparseNumberMap",
         "aws.protocoltests.restjson.synthetic",
         "SparseJsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_number_map",
     "sparseNumberMap",
 ,
 );
 static SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#SparseJsonMapsOutput$sparseBooleanMap",
         "aws.protocoltests.restjson.synthetic",
         "SparseJsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_boolean_map",
     "sparseBooleanMap",
 ,
 );
 static SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#SparseJsonMapsOutput$sparseStringMap",
         "aws.protocoltests.restjson.synthetic",
         "SparseJsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_string_map",
     "sparseStringMap",
 ,
 );
 static SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#SparseJsonMapsOutput$sparseSetMap",
         "aws.protocoltests.restjson.synthetic",
         "SparseJsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "sparse_set_map",
     "sparseSetMap",
 ,
 );
 static SPARSEJSONMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SPARSEJSONMAPSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP,
         &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_NUMBER_MAP,
         &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_BOOLEAN_MAP,
         &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP,

↧ Expand context

         &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_SET_MAP,
     ],
 );
 impl SparseJsonMapsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SPARSEJSONMAPSOUTPUT_SCHEMA;
-117
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SparseJsonMapsOutput {
     #[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.sparse_struct_map {
             ser.write_map(
                 &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {

@@ -178,178 +379,390 @@

↥ Expand context

                 },
             )?;
-180
+        }
         if let Some(ref val) = self.sparse_string_map {
             ser.write_map(
                 &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-190
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-193
+                            }
-194
+                        }
-195
+                    }
                     Ok(())
                 },

             )?;
-199
+        }
         if let Some(ref val) = self.sparse_set_map {
             ser.write_map(
                 &SPARSEJSONMAPSOUTPUT_MEMBER_SPARSE_SET_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         match value {
                             Some(value) => {
                                 todo!("schema: unsupported map value type");
                                 ser.write_list(
                                     &::aws_smithy_schema::prelude::DOCUMENT,
                                     &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                         for item in value {
                                             ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                        }
                                         Ok(())
                                     },
                                 )?;
-217
+                            }
                             None => {
                                 ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
-220
+                            }
-221
+                        }
-222
+                    }
                     Ok(())
                 },
             )?;
-226
+        }
         Ok(())
-228
+    }
-229
+}
 impl SparseJsonMapsOutput {
     /// 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(&SPARSEJSONMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SPARSEJSONMAPSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.sparse_struct_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(crate::types::GreetingStruct::deserialize(deser)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-263
+                }
                 Some(1) => {
                     builder.sparse_number_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_integer(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-281
+                }
                 Some(2) => {
                     builder.sparse_boolean_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_boolean(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-299
+                }
                 Some(3) => {
                     builder.sparse_string_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(deser.read_string(member)?)
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-317
+                }
                 Some(4) => {
                     builder.sparse_set_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(
                                 key,
                                 if deser.is_null() {
                                     deser.read_string(member).ok();
                                     deser.read_null()?;
                                     None
                                 } else {
                                     Some(todo!("deserialize nested aggregate"))
                                     Some({
                                         let mut list = Vec::new();
                                         deser.read_list(member, &mut |deser| {
                                             list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                             Ok(())
                                         })?;
                                         list
                                     })
                                 },
                             );
                             Ok(map)
                         })?
                             Ok(())
                         })?;
                         container
                     });
-342
+                }
                 _ => {}
-344
+            }
             Ok(())
         })?;
         Ok(builder.build())
-348
+    }
-349
+}
 impl SparseJsonMapsOutput {
     /// 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 SparseJsonMapsOutput {
     /// Creates a new builder-style object to manufacture [`SparseJsonMapsOutput`](crate::operation::sparse_json_maps::SparseJsonMapsOutput).
     pub fn builder() -> crate::operation::sparse_json_maps::builders::SparseJsonMapsOutputBuilder {
         crate::operation::sparse_json_maps::builders::SparseJsonMapsOutputBuilder::default()
-365
+    }
-366
+}
-367
 /// A builder for [`SparseJsonMapsOutput`](crate::operation::sparse_json_maps::SparseJsonMapsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SparseJsonMapsOutputBuilder {
     pub(crate) sparse_struct_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<crate::types::GreetingStruct>>>,
     pub(crate) sparse_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<i32>>>,
     pub(crate) sparse_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<bool>>>,
     pub(crate) sparse_string_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::string::String>>>,
     pub(crate) sparse_set_map:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::option::Option<::std::vec::Vec<::std::string::String>>>>,
-380
+}
 impl SparseJsonMapsOutputBuilder {
     /// Adds a key-value pair to `sparse_struct_map`.
     ///
     /// To override the contents of this collection use [`set_sparse_struct_map`](Self::set_sparse_struct_map).
     ///
     pub fn sparse_struct_map(
         mut self,
         k: impl ::std::convert::Into<::std::string::String>,
         v: ::std::option::Option<crate::types::GreetingStruct>,
     ) -> Self {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingTraits`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingTraits;
 impl StreamingTraits {
     /// Creates a new `StreamingTraits`
     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_traits::StreamingTraitsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::streaming_traits::StreamingTraitsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_traits::StreamingTraitsInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_traits::StreamingTraitsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_traits::StreamingTraitsError,
             ::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_traits::StreamingTraitsError>()
                     .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_traits::StreamingTraitsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -129,133 +244,237 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_traits::StreamingTraitsError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct StreamingTraitsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingTraitsResponseDeserializer {
     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;
-150
         // 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;
-154
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_traits::de_streaming_traits_http_response(response),
         ))
-158
+    }
-159
     fn deserialize_nonstreaming(
         &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_traits::de_streaming_traits_http_error(
             response.status().as_u16(),
             response.headers(),
             body,
         let status = response.status().as_u16();
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
             ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         })?;
-+
         let generic = generic_builder.build();
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(crate::operation::streaming_traits::StreamingTraitsError::generic(
                 generic,
             )),
         ))
-180
+    }
-181
+}
 #[derive(Debug)]
 struct StreamingTraitsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingTraitsRequestSerializer {
     #[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_traits::StreamingTraitsInput>()
             .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_traits::StreamingTraitsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/StreamingTraits").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_traits::StreamingTraitsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_streaming_traits::ser_streaming_traits_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_streaming_traits_input::ser_blob_http_payload(input.blob)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, StreamingTraits::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         // Streaming blob payload: replace the body with the raw ByteStream.
         *request.body_mut() = input.blob.into_inner();
         request.headers_mut().insert("Content-Type", "application/octet-stream");
         if let ::std::option::Option::Some(content_length) = request.body().content_length() {
             request.headers_mut().insert("Content-Length", content_length.to_string());
-205
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-208
+    }
-209
+}
 #[derive(Debug)]
 struct StreamingTraitsEndpointParamsInterceptor;
-212
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingTraitsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingTraitsEndpointParamsInterceptor"
-216
+    }
-217

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StreamingTraitsInput>()
             .ok_or("failed to downcast to StreamingTraitsInput")?;
-232
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

@@ -331,324 +437,450 @@

↥ Expand context

             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/octet-stream")
                 .header("X-Foo", "Foo")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("blobby blob blob"))
                 .unwrap(),
-335
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-339
         let op = crate::operation::streaming_traits::StreamingTraits::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-345
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::streaming_traits::StreamingTraitsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(
             parsed.blob.collect().await.unwrap().into_bytes(),
             expected_output.blob.collect().await.unwrap().into_bytes()
         );
-375
+    }
-376
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_no_blob_body_response() {
         let expected_output = crate::operation::streaming_traits::StreamingTraitsOutput::builder()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Foo", "Foo")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-391
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-395
         let op = crate::operation::streaming_traits::StreamingTraits::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-401
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::streaming_traits::StreamingTraitsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(
             parsed.blob.collect().await.unwrap().into_bytes(),
             expected_output.blob.collect().await.unwrap().into_bytes()
         );

↧ Expand context

-431
+    }
-432
+}
-433
 /// Error type for the `StreamingTraitsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum StreamingTraitsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-441
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-443
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-StreamingTraitsError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-446
+}
 impl StreamingTraitsError {
     /// Creates the `StreamingTraitsError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits/_streaming_traits_input.rs

@@ -22,22 +136,173 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic#StreamingTraitsInput",
     "aws.protocoltests.restjson.synthetic",
     "StreamingTraitsInput",
 );
 static STREAMINGTRAITSINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
-35
+)
 .with_http_header("X-Foo");
 static STREAMINGTRAITSINPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsInput$blob",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsInput",

     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
 ,
-46
+)
 .with_http_payload();
 static STREAMINGTRAITSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGTRAITSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STREAMINGTRAITSINPUT_MEMBER_FOO, &STREAMINGTRAITSINPUT_MEMBER_BLOB],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/StreamingTraits", None));
 impl StreamingTraitsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGTRAITSINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingTraitsInput {
     #[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.foo {
             ser.write_string(&STREAMINGTRAITSINPUT_MEMBER_FOO, val)?;
-66
+        }
--
+        {
             let val = &self.blob;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-68
+    }
-69
+}
 impl StreamingTraitsInput {
     /// 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(&STREAMINGTRAITSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGTRAITSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-88
+                }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-102
+    }
-103
+}
 impl StreamingTraitsInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("X-Foo") {
             builder.foo = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGTRAITSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StreamingTraitsInput {
     /// Creates a new builder-style object to manufacture [`StreamingTraitsInput`](crate::operation::streaming_traits::StreamingTraitsInput).
     pub fn builder() -> crate::operation::streaming_traits::builders::StreamingTraitsInputBuilder {
         crate::operation::streaming_traits::builders::StreamingTraitsInputBuilder::default()
-148
+    }
-149
+}
-150
 /// A builder for [`StreamingTraitsInput`](crate::operation::streaming_traits::StreamingTraitsInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StreamingTraitsInputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-157
+}
 impl StreamingTraitsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-163
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-168
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-172
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits/_streaming_traits_output.rs

@@ -36,36 +134,168 @@

↥ Expand context

 .with_http_header("X-Foo");
 static STREAMINGTRAITSOUTPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsOutput$blob",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
 ,
-46
+)
 .with_http_payload();
 static STREAMINGTRAITSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGTRAITSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STREAMINGTRAITSOUTPUT_MEMBER_FOO, &STREAMINGTRAITSOUTPUT_MEMBER_BLOB],
 );
 impl StreamingTraitsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGTRAITSOUTPUT_SCHEMA;

-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingTraitsOutput {
     #[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.foo {
             ser.write_string(&STREAMINGTRAITSOUTPUT_MEMBER_FOO, val)?;
-65
+        }
--
+        {
             let val = &self.blob;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-67
+    }
-68
+}
 impl StreamingTraitsOutput {
     /// 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(&STREAMINGTRAITSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGTRAITSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-87
+                }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         Ok(builder.build())
-99
+    }
-100
+}
 impl StreamingTraitsOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("X-Foo") {
             builder.foo = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGTRAITSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl StreamingTraitsOutput {
     /// Creates a new builder-style object to manufacture [`StreamingTraitsOutput`](crate::operation::streaming_traits::StreamingTraitsOutput).
     pub fn builder() -> crate::operation::streaming_traits::builders::StreamingTraitsOutputBuilder {
         crate::operation::streaming_traits::builders::StreamingTraitsOutputBuilder::default()
-143
+    }
-144
+}
-145
 /// A builder for [`StreamingTraitsOutput`](crate::operation::streaming_traits::StreamingTraitsOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StreamingTraitsOutputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-152
+}
 impl StreamingTraitsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-158
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-163
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-167
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits_require_length.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingTraitsRequireLength`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingTraitsRequireLength;
 impl StreamingTraitsRequireLength {
     /// Creates a new `StreamingTraitsRequireLength`
     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_traits_require_length::StreamingTraitsRequireLengthInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthError,
             ::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_traits_require_length::StreamingTraitsRequireLengthError>()
                     .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_traits_require_length::StreamingTraitsRequireLengthOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -113,119 +234,247 @@

↥ Expand context

         ));
-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("StreamingTraitsRequireLength")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StreamingTraitsRequireLengthEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthError,
             >::new());
-138

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct StreamingTraitsRequireLengthResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingTraitsRequireLengthResponseDeserializer {
     fn deserialize_nonstreaming(
         &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;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, StreamingTraitsRequireLength::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct StreamingTraitsRequireLengthRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingTraitsRequireLengthRequestSerializer {
     #[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_traits_require_length::StreamingTraitsRequireLengthInput>()
             .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_traits_require_length::StreamingTraitsRequireLengthInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/StreamingTraitsRequireLength").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_streaming_traits_require_length::ser_streaming_traits_require_length_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_streaming_traits_require_length_input::ser_blob_http_payload(input.blob)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, StreamingTraitsRequireLength::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         // Streaming blob payload: replace the body with the raw ByteStream.
         *request.body_mut() = input.blob.into_inner();
         request.headers_mut().insert("Content-Type", "application/octet-stream");
         if let ::std::option::Option::Some(content_length) = request.body().content_length() {
             request.headers_mut().insert("Content-Length", content_length.to_string());
-215
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-218
+    }
-219
+}
 #[derive(Debug)]
 struct StreamingTraitsRequireLengthEndpointParamsInterceptor;
-222
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingTraitsRequireLengthEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingTraitsRequireLengthEndpointParamsInterceptor"
-226
+    }
-227

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StreamingTraitsRequireLengthInput>()
             .ok_or("failed to downcast to StreamingTraitsRequireLengthInput")?;
-242
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits_require_length/_streaming_traits_require_length_input.rs

@@ -25,25 +139,176 @@

↥ Expand context

 );
 static STREAMINGTRAITSREQUIRELENGTHINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsRequireLengthInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsRequireLengthInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
-35
+)
 .with_http_header("X-Foo");
 static STREAMINGTRAITSREQUIRELENGTHINPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsRequireLengthInput$blob",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsRequireLengthInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",

 ,
-46
+)
 .with_http_payload();
 static STREAMINGTRAITSREQUIRELENGTHINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGTRAITSREQUIRELENGTHINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGTRAITSREQUIRELENGTHINPUT_MEMBER_FOO,
         &STREAMINGTRAITSREQUIRELENGTHINPUT_MEMBER_BLOB,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/StreamingTraitsRequireLength", None));
 impl StreamingTraitsRequireLengthInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGTRAITSREQUIRELENGTHINPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingTraitsRequireLengthInput {
     #[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.foo {
             ser.write_string(&STREAMINGTRAITSREQUIRELENGTHINPUT_MEMBER_FOO, val)?;
-69
+        }
--
+        {
             let val = &self.blob;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-71
+    }
-72
+}
 impl StreamingTraitsRequireLengthInput {
     /// 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(&STREAMINGTRAITSREQUIRELENGTHINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGTRAITSREQUIRELENGTHINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-91
+                }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-97
+                }
                 _ => {}
-99
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-105
+    }
-106
+}
 impl StreamingTraitsRequireLengthInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("X-Foo") {
             builder.foo = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGTRAITSREQUIRELENGTHINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StreamingTraitsRequireLengthInput {
     /// Creates a new builder-style object to manufacture [`StreamingTraitsRequireLengthInput`](crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthInput).
     pub fn builder() -> crate::operation::streaming_traits_require_length::builders::StreamingTraitsRequireLengthInputBuilder {
         crate::operation::streaming_traits_require_length::builders::StreamingTraitsRequireLengthInputBuilder::default()
-151
+    }
-152
+}
-153
 /// A builder for [`StreamingTraitsRequireLengthInput`](crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StreamingTraitsRequireLengthInputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-160
+}
 impl StreamingTraitsRequireLengthInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-166
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-171
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-175
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits_require_length/_streaming_traits_require_length_output.rs

@@ -1,1 +68,79 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct StreamingTraitsRequireLengthOutput {}
 static STREAMINGTRAITSREQUIRELENGTHOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#StreamingTraitsRequireLengthOutput",
     "aws.protocoltests.restjson.synthetic",
     "StreamingTraitsRequireLengthOutput",
 );
 static STREAMINGTRAITSREQUIRELENGTHOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGTRAITSREQUIRELENGTHOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
 impl StreamingTraitsRequireLengthOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGTRAITSREQUIRELENGTHOUTPUT_SCHEMA;
-19
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingTraitsRequireLengthOutput {

     #[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> {
         Ok(())
-27
+    }
-28
+}
 impl StreamingTraitsRequireLengthOutput {
     /// 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(&STREAMINGTRAITSREQUIRELENGTHOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGTRAITSREQUIRELENGTHOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-46
+            }
             Ok(())
         })?;
         Ok(builder.build())
-50
+    }
-51
+}
 impl StreamingTraitsRequireLengthOutput {
     /// 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> {
         Ok(Self::builder().build())
-+
+    }
-+
+}
 impl StreamingTraitsRequireLengthOutput {
     /// Creates a new builder-style object to manufacture [`StreamingTraitsRequireLengthOutput`](crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput).
     pub fn builder() -> crate::operation::streaming_traits_require_length::builders::StreamingTraitsRequireLengthOutputBuilder {
         crate::operation::streaming_traits_require_length::builders::StreamingTraitsRequireLengthOutputBuilder::default()
-67
+    }
-68
+}
-69
 /// A builder for [`StreamingTraitsRequireLengthOutput`](crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StreamingTraitsRequireLengthOutputBuilder {}
 impl StreamingTraitsRequireLengthOutputBuilder {
     /// Consumes the builder and constructs a [`StreamingTraitsRequireLengthOutput`](crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput).
     pub fn build(self) -> crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput {
         crate::operation::streaming_traits_require_length::StreamingTraitsRequireLengthOutput {}
-78
+    }
-79
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits_with_media_type.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StreamingTraitsWithMediaType`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StreamingTraitsWithMediaType;
 impl StreamingTraitsWithMediaType {
     /// Creates a new `StreamingTraitsWithMediaType`
     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_traits_with_media_type::StreamingTraitsWithMediaTypeInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeInput,
     ) -> ::std::result::Result<
         crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeError,
             ::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_traits_with_media_type::StreamingTraitsWithMediaTypeError>()
                     .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_traits_with_media_type::StreamingTraitsWithMediaTypeOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -129,135 +247,239 @@

↥ Expand context

             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct StreamingTraitsWithMediaTypeResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StreamingTraitsWithMediaTypeResponseDeserializer {
     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;
-152
         // 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;
-156
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_streaming_traits_with_media_type::de_streaming_traits_with_media_type_http_response(response),
         ))
-160
+    }
-161
     fn deserialize_nonstreaming(
         &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_traits_with_media_type::de_streaming_traits_with_media_type_http_error(
                 response.status().as_u16(),
                 response.headers(),
                 body,
         let status = response.status().as_u16();
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
             ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         })?;
-+
         let generic = generic_builder.build();
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                 crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeError::generic(generic),
             ),
--
+        )
         ))
-182
+    }
-183
+}
 #[derive(Debug)]
 struct StreamingTraitsWithMediaTypeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StreamingTraitsWithMediaTypeRequestSerializer {
     #[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_traits_with_media_type::StreamingTraitsWithMediaTypeInput>()
             .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_traits_with_media_type::StreamingTraitsWithMediaTypeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/StreamingTraitsWithMediaType").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_streaming_traits_with_media_type::ser_streaming_traits_with_media_type_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "text/plain");
             builder
         };
         let body = crate::protocol_serde::shape_streaming_traits_with_media_type_input::ser_blob_http_payload(input.blob)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, StreamingTraitsWithMediaType::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         // Streaming blob payload: replace the body with the raw ByteStream.
         *request.body_mut() = input.blob.into_inner();
         request.headers_mut().insert("Content-Type", "text/plain");
         if let ::std::option::Option::Some(content_length) = request.body().content_length() {
             request.headers_mut().insert("Content-Length", content_length.to_string());
-207
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct StreamingTraitsWithMediaTypeEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StreamingTraitsWithMediaTypeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StreamingTraitsWithMediaTypeEndpointParamsInterceptor"
-218
+    }
-219

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StreamingTraitsWithMediaTypeInput>()
             .ok_or("failed to downcast to StreamingTraitsWithMediaTypeInput")?;
-234
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

@@ -303,295 +363,365 @@

↥ Expand context

             .set_blob(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"blobby blob blob",
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "text/plain")
                 .header("X-Foo", "Foo")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("blobby blob blob"))
                 .unwrap(),
-306
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-310
         let op = crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaType::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-316
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(
             parsed.blob.collect().await.unwrap().into_bytes(),
             expected_output.blob.collect().await.unwrap().into_bytes()
         );

↧ Expand context

-346
+    }
-347
+}
-348
 /// Error type for the `StreamingTraitsWithMediaTypeError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum StreamingTraitsWithMediaTypeError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-356
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-358
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-StreamingTraitsWithMediaTypeError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-361
+}
 impl StreamingTraitsWithMediaTypeError {
     /// Creates the `StreamingTraitsWithMediaTypeError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits_with_media_type/_streaming_traits_with_media_type_input.rs

@@ -25,25 +139,176 @@

↥ Expand context

 );
 static STREAMINGTRAITSWITHMEDIATYPEINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsWithMediaTypeInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsWithMediaTypeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
-35
+)
 .with_http_header("X-Foo");
 static STREAMINGTRAITSWITHMEDIATYPEINPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#StreamingTraitsWithMediaTypeInput$blob",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsWithMediaTypeInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",

 ,
-46
+)
 .with_http_payload();
 static STREAMINGTRAITSWITHMEDIATYPEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGTRAITSWITHMEDIATYPEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGTRAITSWITHMEDIATYPEINPUT_MEMBER_FOO,
         &STREAMINGTRAITSWITHMEDIATYPEINPUT_MEMBER_BLOB,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/StreamingTraitsWithMediaType", None));
 impl StreamingTraitsWithMediaTypeInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGTRAITSWITHMEDIATYPEINPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingTraitsWithMediaTypeInput {
     #[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.foo {
             ser.write_string(&STREAMINGTRAITSWITHMEDIATYPEINPUT_MEMBER_FOO, val)?;
-69
+        }
--
+        {
             let val = &self.blob;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-71
+    }
-72
+}
 impl StreamingTraitsWithMediaTypeInput {
     /// 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(&STREAMINGTRAITSWITHMEDIATYPEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGTRAITSWITHMEDIATYPEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-91
+                }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-97
+                }
                 _ => {}
-99
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-105
+    }
-106
+}
 impl StreamingTraitsWithMediaTypeInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("X-Foo") {
             builder.foo = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGTRAITSWITHMEDIATYPEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StreamingTraitsWithMediaTypeInput {
     /// Creates a new builder-style object to manufacture [`StreamingTraitsWithMediaTypeInput`](crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeInput).
     pub fn builder() -> crate::operation::streaming_traits_with_media_type::builders::StreamingTraitsWithMediaTypeInputBuilder {
         crate::operation::streaming_traits_with_media_type::builders::StreamingTraitsWithMediaTypeInputBuilder::default()
-151
+    }
-152
+}
-153
 /// A builder for [`StreamingTraitsWithMediaTypeInput`](crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StreamingTraitsWithMediaTypeInputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-160
+}
 impl StreamingTraitsWithMediaTypeInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-166
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-171
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-175
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/streaming_traits_with_media_type/_streaming_traits_with_media_type_output.rs

@@ -39,39 +137,171 @@

↥ Expand context

         "aws.protocoltests.restjson.synthetic#StreamingTraitsWithMediaTypeOutput$blob",
         "aws.protocoltests.restjson.synthetic",
         "StreamingTraitsWithMediaTypeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
 ,
-46
+)
 .with_http_payload();
 static STREAMINGTRAITSWITHMEDIATYPEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STREAMINGTRAITSWITHMEDIATYPEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STREAMINGTRAITSWITHMEDIATYPEOUTPUT_MEMBER_FOO,
         &STREAMINGTRAITSWITHMEDIATYPEOUTPUT_MEMBER_BLOB,
     ],
 );
 impl StreamingTraitsWithMediaTypeOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STREAMINGTRAITSWITHMEDIATYPEOUTPUT_SCHEMA;

-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StreamingTraitsWithMediaTypeOutput {
     #[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.foo {
             ser.write_string(&STREAMINGTRAITSWITHMEDIATYPEOUTPUT_MEMBER_FOO, val)?;
-68
+        }
--
+        {
             let val = &self.blob;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-70
+    }
-71
+}
 impl StreamingTraitsWithMediaTypeOutput {
     /// 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(&STREAMINGTRAITSWITHMEDIATYPEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STREAMINGTRAITSWITHMEDIATYPEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-96
+                }
                 _ => {}
-98
+            }
             Ok(())
         })?;
         Ok(builder.build())
-102
+    }
-103
+}
 impl StreamingTraitsWithMediaTypeOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("X-Foo") {
             builder.foo = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STREAMINGTRAITSWITHMEDIATYPEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.blob = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl StreamingTraitsWithMediaTypeOutput {
     /// Creates a new builder-style object to manufacture [`StreamingTraitsWithMediaTypeOutput`](crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeOutput).
     pub fn builder() -> crate::operation::streaming_traits_with_media_type::builders::StreamingTraitsWithMediaTypeOutputBuilder {
         crate::operation::streaming_traits_with_media_type::builders::StreamingTraitsWithMediaTypeOutputBuilder::default()
-146
+    }
-147
+}
-148
 /// A builder for [`StreamingTraitsWithMediaTypeOutput`](crate::operation::streaming_traits_with_media_type::StreamingTraitsWithMediaTypeOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StreamingTraitsWithMediaTypeOutputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-155
+}
 impl StreamingTraitsWithMediaTypeOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-161
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-166
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-170
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_body_structure.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `TestBodyStructure`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct TestBodyStructure;
 impl TestBodyStructure {
     /// Creates a new `TestBodyStructure`
     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::test_body_structure::TestBodyStructureInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_body_structure::TestBodyStructureOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::test_body_structure::TestBodyStructureInput,
     ) -> ::std::result::Result<
         crate::operation::test_body_structure::TestBodyStructureOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::test_body_structure::TestBodyStructureError,
             ::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::test_body_structure::TestBodyStructureError>()
                     .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::test_body_structure::TestBodyStructureOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -113,117 +233,269 @@

↥ Expand context

         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     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("TestBodyStructure")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(TestBodyStructureEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::test_body_structure::TestBodyStructureError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::test_body_structure::TestBodyStructureError,
             >::new());
-136

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct TestBodyStructureResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestBodyStructureResponseDeserializer {
     fn deserialize_nonstreaming(
         &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;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::test_body_structure::TestBodyStructureError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, TestBodyStructure::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::test_body_structure::TestBodyStructureOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct TestBodyStructureRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestBodyStructureRequestSerializer {
     #[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::test_body_structure::TestBodyStructureInput>()
             .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::test_body_structure::TestBodyStructureInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/body").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::test_body_structure::TestBodyStructureInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, TestBodyStructure::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/body".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.test_id {
                     request.headers_mut().insert("x-amz-test-id", val.to_string());
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-230
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, TestBodyStructure::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-239
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-240
+    }
-241
+}
 #[derive(Debug)]
 struct TestBodyStructureEndpointParamsInterceptor;
-244
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestBodyStructureEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestBodyStructureEndpointParamsInterceptor"
-248
+    }
-249

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<TestBodyStructureInput>()
             .ok_or("failed to downcast to TestBodyStructureInput")?;
-264
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_body_structure/_test_body_structure_input.rs

@@ -3,3 +131,169 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TestBodyStructureInput {
     #[allow(missing_docs)] // documentation missing in model
     pub test_id: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub test_config: ::std::option::Option<crate::types::TestConfig>,
-10
+}
 impl TestBodyStructureInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_id(&self) -> ::std::option::Option<&str> {
         self.test_id.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_config(&self) -> ::std::option::Option<&crate::types::TestConfig> {
         self.test_config.as_ref()
-19
+    }
-20
+}
 static TESTBODYSTRUCTUREINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#TestBodyStructureInput",

     "aws.protocoltests.restjson.synthetic",
     "TestBodyStructureInput",
 );
 static TESTBODYSTRUCTUREINPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#TestBodyStructureInput$testId",
         "aws.protocoltests.restjson.synthetic",
         "TestBodyStructureInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "test_id",
     "testId",
 ,
-35
+)
 .with_http_header("x-amz-test-id");
 static TESTBODYSTRUCTUREINPUT_MEMBER_TEST_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#TestBodyStructureInput$testConfig",
         "aws.protocoltests.restjson.synthetic",
         "TestBodyStructureInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "test_config",
     "testConfig",
 ,
 );
 static TESTBODYSTRUCTUREINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTBODYSTRUCTUREINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TESTBODYSTRUCTUREINPUT_MEMBER_TEST_ID, &TESTBODYSTRUCTUREINPUT_MEMBER_TEST_CONFIG],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/body", None));
 impl TestBodyStructureInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTBODYSTRUCTUREINPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestBodyStructureInput {
     #[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.test_id {
             ser.write_string(&TESTBODYSTRUCTUREINPUT_MEMBER_TEST_ID, val)?;
-65
+        }
         if let Some(ref val) = self.test_config {
             ser.write_struct(&TESTBODYSTRUCTUREINPUT_MEMBER_TEST_CONFIG, val)?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl TestBodyStructureInput {
     /// 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(&TESTBODYSTRUCTUREINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTBODYSTRUCTUREINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.test_id = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     builder.test_config = Some(crate::types::TestConfig::deserialize(deser)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-101
+    }
-102
+}
 impl TestBodyStructureInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-test-id") {
             builder.test_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&TESTBODYSTRUCTUREINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.test_config = Some(crate::types::TestConfig::deserialize(deser)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl TestBodyStructureInput {
     /// Creates a new builder-style object to manufacture [`TestBodyStructureInput`](crate::operation::test_body_structure::TestBodyStructureInput).
     pub fn builder() -> crate::operation::test_body_structure::builders::TestBodyStructureInputBuilder {
         crate::operation::test_body_structure::builders::TestBodyStructureInputBuilder::default()
-144
+    }
-145
+}
-146
 /// A builder for [`TestBodyStructureInput`](crate::operation::test_body_structure::TestBodyStructureInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TestBodyStructureInputBuilder {
     pub(crate) test_id: ::std::option::Option<::std::string::String>,
     pub(crate) test_config: ::std::option::Option<crate::types::TestConfig>,
-153
+}
 impl TestBodyStructureInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.test_id = ::std::option::Option::Some(input.into());
         self
-159
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_test_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.test_id = input;
         self
-164
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_test_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.test_id
-168
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_body_structure/_test_body_structure_output.rs

@@ -3,3 +129,164 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TestBodyStructureOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub test_id: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub test_config: ::std::option::Option<crate::types::TestConfig>,
-10
+}
 impl TestBodyStructureOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_id(&self) -> ::std::option::Option<&str> {
         self.test_id.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_config(&self) -> ::std::option::Option<&crate::types::TestConfig> {
         self.test_config.as_ref()
-19
+    }
-20
+}
 static TESTBODYSTRUCTUREOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#TestBodyStructureOutput",

     "aws.protocoltests.restjson.synthetic",
     "TestBodyStructureOutput",
 );
 static TESTBODYSTRUCTUREOUTPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#TestBodyStructureOutput$testId",
         "aws.protocoltests.restjson.synthetic",
         "TestBodyStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "test_id",
     "testId",
 ,
-35
+)
 .with_http_header("x-amz-test-id");
 static TESTBODYSTRUCTUREOUTPUT_MEMBER_TEST_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#TestBodyStructureOutput$testConfig",
         "aws.protocoltests.restjson.synthetic",
         "TestBodyStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "test_config",
     "testConfig",
 ,
 );
 static TESTBODYSTRUCTUREOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTBODYSTRUCTUREOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TESTBODYSTRUCTUREOUTPUT_MEMBER_TEST_ID, &TESTBODYSTRUCTUREOUTPUT_MEMBER_TEST_CONFIG],
 );
 impl TestBodyStructureOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTBODYSTRUCTUREOUTPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestBodyStructureOutput {
     #[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.test_id {
             ser.write_string(&TESTBODYSTRUCTUREOUTPUT_MEMBER_TEST_ID, val)?;
-64
+        }
         if let Some(ref val) = self.test_config {
             ser.write_struct(&TESTBODYSTRUCTUREOUTPUT_MEMBER_TEST_CONFIG, val)?;
-67
+        }
         Ok(())
-69
+    }
-70
+}
 impl TestBodyStructureOutput {
     /// 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(&TESTBODYSTRUCTUREOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTBODYSTRUCTUREOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.test_id = Some(deser.read_string(member)?);
-89
+                }
                 Some(1) => {
                     builder.test_config = Some(crate::types::TestConfig::deserialize(deser)?);
-92
+                }
                 _ => {}
-94
+            }
             Ok(())
         })?;
         Ok(builder.build())
-98
+    }
-99
+}
 impl TestBodyStructureOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-test-id") {
             builder.test_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&TESTBODYSTRUCTUREOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.test_config = Some(crate::types::TestConfig::deserialize(deser)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl TestBodyStructureOutput {
     /// Creates a new builder-style object to manufacture [`TestBodyStructureOutput`](crate::operation::test_body_structure::TestBodyStructureOutput).
     pub fn builder() -> crate::operation::test_body_structure::builders::TestBodyStructureOutputBuilder {
         crate::operation::test_body_structure::builders::TestBodyStructureOutputBuilder::default()
-139
+    }
-140
+}
-141
 /// A builder for [`TestBodyStructureOutput`](crate::operation::test_body_structure::TestBodyStructureOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TestBodyStructureOutputBuilder {
     pub(crate) test_id: ::std::option::Option<::std::string::String>,
     pub(crate) test_config: ::std::option::Option<crate::types::TestConfig>,
-148
+}
 impl TestBodyStructureOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.test_id = ::std::option::Option::Some(input.into());
         self
-154
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_test_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.test_id = input;
         self
-159
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_test_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.test_id
-163
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_get_no_input_no_payload.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `TestGetNoInputNoPayload`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct TestGetNoInputNoPayload;
 impl TestGetNoInputNoPayload {
     /// Creates a new `TestGetNoInputNoPayload`
     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::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput,
     ) -> ::std::result::Result<
         crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadError,
             ::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::test_get_no_input_no_payload::TestGetNoInputNoPayloadError>()
                     .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::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -113,119 +228,241 @@

↥ Expand context

         ));
-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("TestGetNoInputNoPayload")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(TestGetNoInputNoPayloadEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadError,
             >::new());
-138

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct TestGetNoInputNoPayloadResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestGetNoInputNoPayloadResponseDeserializer {
     fn deserialize_nonstreaming(
         &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;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_test_get_no_input_no_payload::de_test_get_no_input_no_payload_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_test_get_no_input_no_payload::de_test_get_no_input_no_payload_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, TestGetNoInputNoPayload::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct TestGetNoInputNoPayloadRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestGetNoInputNoPayloadRequestSerializer {
     #[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::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput>()
             .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::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/no_input_no_payload").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, TestGetNoInputNoPayload::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-210
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct TestGetNoInputNoPayloadEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestGetNoInputNoPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestGetNoInputNoPayloadEndpointParamsInterceptor"
-220
+    }
-221

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<TestGetNoInputNoPayloadInput>()
             .ok_or("failed to downcast to TestGetNoInputNoPayloadInput")?;
-236
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_get_no_input_no_payload/_test_get_no_input_no_payload_input.rs

@@ -1,1 +72,86 @@

↥ Expand context

 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TestGetNoInputNoPayloadInput {}
 static TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#TestGetNoInputNoPayloadInput",
     "aws.protocoltests.restjson.synthetic",
     "TestGetNoInputNoPayloadInput",
 );
 static TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
     ::aws_smithy_schema::Schema::new_struct(TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
         .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/no_input_no_payload", None));
 impl TestGetNoInputNoPayloadInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA;
-17
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestGetNoInputNoPayloadInput {
     #[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> {
         Ok(())
-25
+    }
-26
+}
 impl TestGetNoInputNoPayloadInput {
     /// 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(&TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTGETNOINPUTNOPAYLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-44
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-50
+    }
-51
+}
 impl TestGetNoInputNoPayloadInput {
     /// 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::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl TestGetNoInputNoPayloadInput {
     /// Creates a new builder-style object to manufacture [`TestGetNoInputNoPayloadInput`](crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput).
     pub fn builder() -> crate::operation::test_get_no_input_no_payload::builders::TestGetNoInputNoPayloadInputBuilder {
         crate::operation::test_get_no_input_no_payload::builders::TestGetNoInputNoPayloadInputBuilder::default()
-69
+    }
-70
+}
-71
 /// A builder for [`TestGetNoInputNoPayloadInput`](crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TestGetNoInputNoPayloadInputBuilder {}
 impl TestGetNoInputNoPayloadInputBuilder {
     /// Consumes the builder and constructs a [`TestGetNoInputNoPayloadInput`](crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<
         crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput,
         ::aws_smithy_types::error::operation::BuildError,
     > {
         ::std::result::Result::Ok(crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadInput {})
-85
+    }
-86
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/test_get_no_input_no_payload/_test_get_no_input_no_payload_output.rs

@@ -1,1 +107,125 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TestGetNoInputNoPayloadOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub test_id: ::std::option::Option<::std::string::String>,
-8
+}
 impl TestGetNoInputNoPayloadOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_id(&self) -> ::std::option::Option<&str> {
         self.test_id.as_deref()
-13
+    }
-14
+}
 static TESTGETNOINPUTNOPAYLOADOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#TestGetNoInputNoPayloadOutput",

     "aws.protocoltests.restjson.synthetic",
     "TestGetNoInputNoPayloadOutput",
 );
 static TESTGETNOINPUTNOPAYLOADOUTPUT_MEMBER_TEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#TestGetNoInputNoPayloadOutput$testId",
         "aws.protocoltests.restjson.synthetic",
         "TestGetNoInputNoPayloadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "test_id",
     "testId",
 ,
-29
+)
 .with_http_header("X-Amz-Test-Id");
 static TESTGETNOINPUTNOPAYLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTGETNOINPUTNOPAYLOADOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TESTGETNOINPUTNOPAYLOADOUTPUT_MEMBER_TEST_ID],
 );
 impl TestGetNoInputNoPayloadOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTGETNOINPUTNOPAYLOADOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestGetNoInputNoPayloadOutput {
     #[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.test_id {
             ser.write_string(&TESTGETNOINPUTNOPAYLOADOUTPUT_MEMBER_TEST_ID, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl TestGetNoInputNoPayloadOutput {
     /// 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(&TESTGETNOINPUTNOPAYLOADOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTGETNOINPUTNOPAYLOADOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.test_id = Some(deser.read_string(member)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl TestGetNoInputNoPayloadOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     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> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("X-Amz-Test-Id") {
             builder.test_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl TestGetNoInputNoPayloadOutput {
     /// Creates a new builder-style object to manufacture [`TestGetNoInputNoPayloadOutput`](crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput).
     pub fn builder() -> crate::operation::test_get_no_input_no_payload::builders::TestGetNoInputNoPayloadOutputBuilder {
         crate::operation::test_get_no_input_no_payload::builders::TestGetNoInputNoPayloadOutputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`TestGetNoInputNoPayloadOutput`](crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TestGetNoInputNoPayloadOutputBuilder {
     pub(crate) test_id: ::std::option::Option<::std::string::String>,
-108
+}
 impl TestGetNoInputNoPayloadOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn test_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.test_id = ::std::option::Option::Some(input.into());
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_test_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.test_id = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_test_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.test_id
-123
+    }
     /// Consumes the builder and constructs a [`TestGetNoInputNoPayloadOutput`](crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput).
     pub fn build(self) -> crate::operation::test_get_no_input_no_payload::TestGetNoInputNoPayloadOutput {

Client Test

Files changed: