Client Test

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

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

         "aws.protocoltests.restjson.synthetic",
         "HttpChecksumRequiredOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
 );
 static HTTPCHECKSUMREQUIREDOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPCHECKSUMREQUIREDOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPCHECKSUMREQUIREDOUTPUT_MEMBER_FOO],
 );
 impl HttpChecksumRequiredOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPCHECKSUMREQUIREDOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpChecksumRequiredOutput {
     #[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(&HTTPCHECKSUMREQUIREDOUTPUT_MEMBER_FOO, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl HttpChecksumRequiredOutput {
     /// 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(&HTTPCHECKSUMREQUIREDOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPCHECKSUMREQUIREDOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl HttpChecksumRequiredOutput {
     /// 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 HttpChecksumRequiredOutput {
     /// Creates a new builder-style object to manufacture [`HttpChecksumRequiredOutput`](crate::operation::http_checksum_required::HttpChecksumRequiredOutput).
     pub fn builder() -> crate::operation::http_checksum_required::builders::HttpChecksumRequiredOutputBuilder {
         crate::operation::http_checksum_required::builders::HttpChecksumRequiredOutputBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`HttpChecksumRequiredOutput`](crate::operation::http_checksum_required::HttpChecksumRequiredOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpChecksumRequiredOutputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
-100
+}
 impl HttpChecksumRequiredOutputBuilder {
     #[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
-106
+    }
     #[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
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-115
+    }
     /// Consumes the builder and constructs a [`HttpChecksumRequiredOutput`](crate::operation::http_checksum_required::HttpChecksumRequiredOutput).
     pub fn build(self) -> crate::operation::http_checksum_required::HttpChecksumRequiredOutput {

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

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

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

@@ -110,114 +275,284 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "HttpEmptyPrefixHeaders",
             "Rest Json Protocol",
         ));
-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("HttpEmptyPrefixHeaders")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HttpEmptyPrefixHeadersEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct HttpEmptyPrefixHeadersResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpEmptyPrefixHeadersResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_empty_prefix_headers::de_http_empty_prefix_headers_http_error(status, headers, body)
             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::http_empty_prefix_headers::HttpEmptyPrefixHeadersError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_empty_prefix_headers::de_http_empty_prefix_headers_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, HttpEmptyPrefixHeaders::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::http_empty_prefix_headers::HttpEmptyPrefixHeadersOutput::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 HttpEmptyPrefixHeadersRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpEmptyPrefixHeadersRequestSerializer {
     #[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::http_empty_prefix_headers::HttpEmptyPrefixHeadersInput>()
             .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::http_empty_prefix_headers::HttpEmptyPrefixHeadersInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/HttpEmptyPrefixHeaders").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersInput,
                 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_http_empty_prefix_headers::ser_http_empty_prefix_headers_headers(input, builder)?;
                 ::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, HttpEmptyPrefixHeaders::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-208
         ::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 HttpEmptyPrefixHeadersEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpEmptyPrefixHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpEmptyPrefixHeadersEndpointParamsInterceptor"
-218
+    }
-219
     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::<HttpEmptyPrefixHeadersInput>()
             .ok_or("failed to downcast to HttpEmptyPrefixHeadersInput")?;
-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));
         ::std::result::Result::Ok(())
-241
+    }
-242
+}
-243
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-246
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_empty_prefix_headers_test {
-250
     /// Serializes all request headers, using specific when present
     /// Test ID: RestJsonHttpEmptyPrefixHeadersRequestClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_http_empty_prefix_headers_request_client_request() {
         let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             // TODO(https://github.com/smithy-lang/smithy-rs/issues/4177):
             //  Until the incorrect separation is addressed, we need to rely on this workaround.
             .allow_no_auth()
             .endpoint_url("https://example.com");
-263
         let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

↧ Expand context

         let result = client
             .http_empty_prefix_headers()
             .set_prefix_headers(::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x-foo".to_owned().to_ascii_lowercase(), "Foo".to_owned());
                 ret.insert("hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());
                 ret
             }))
             .set_specific_header(::std::option::Option::Some("There".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("hello", "There"), ("x-foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body.
         ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());
         let uri: ::http_1x::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

@@ -289,298 +349,368 @@

↥ Expand context

                 ret
             }))
             .set_specific_header(::std::option::Option::Some("There".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("hello", "There")
                 .header("x-foo", "Foo")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-309
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-313
         let op = crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeaders::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");
-319
         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("unknown"),
                 )))
             });
             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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.prefix_headers,
             expected_output.prefix_headers,
             "Unexpected value for `prefix_headers`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.specific_header,
             expected_output.specific_header,
             "Unexpected value for `specific_header`"
         );
-354
+    }
-355
+}
-356
 /// Error type for the `HttpEmptyPrefixHeadersError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpEmptyPrefixHeadersError {
     /// 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()`:
-364
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-366
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpEmptyPrefixHeadersError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),

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

@@ -3,3 +154,176 @@

↥ Expand context

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

     "aws.protocoltests.restjson.synthetic",
     "HttpEmptyPrefixHeadersInput",
 );
 static HTTPEMPTYPREFIXHEADERSINPUT_MEMBER_PREFIX_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpEmptyPrefixHeadersInput$prefixHeaders",
         "aws.protocoltests.restjson.synthetic",
         "HttpEmptyPrefixHeadersInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "prefix_headers",
     "prefixHeaders",
 ,
-35
+)
 .with_http_prefix_headers("");
 static HTTPEMPTYPREFIXHEADERSINPUT_MEMBER_SPECIFIC_HEADER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpEmptyPrefixHeadersInput$specificHeader",
         "aws.protocoltests.restjson.synthetic",
         "HttpEmptyPrefixHeadersInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "specific_header",
     "specificHeader",
 ,
-46
+)
 .with_http_header("hello");
 static HTTPEMPTYPREFIXHEADERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPEMPTYPREFIXHEADERSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &HTTPEMPTYPREFIXHEADERSINPUT_MEMBER_PREFIX_HEADERS,
         &HTTPEMPTYPREFIXHEADERSINPUT_MEMBER_SPECIFIC_HEADER,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/HttpEmptyPrefixHeaders", None));
 impl HttpEmptyPrefixHeadersInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPEMPTYPREFIXHEADERSINPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpEmptyPrefixHeadersInput {
     #[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.prefix_headers {
             ser.write_map(
                 &HTTPEMPTYPREFIXHEADERSINPUT_MEMBER_PREFIX_HEADERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-74
+                    }
                     Ok(())
                 },
             )?;
-78
+        }
         if let Some(ref val) = self.specific_header {
             ser.write_string(&HTTPEMPTYPREFIXHEADERSINPUT_MEMBER_SPECIFIC_HEADER, val)?;
-81
+        }
         Ok(())
-83
+    }
-84
+}
 impl HttpEmptyPrefixHeadersInput {
     /// 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(&HTTPEMPTYPREFIXHEADERSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPEMPTYPREFIXHEADERSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.prefix_headers = 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(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.prefix_headers = Some(deser.read_string_string_map(member)?);
-103
+                }
                 Some(1) => {
                     builder.specific_header = Some(deser.read_string(member)?);
-106
+                }
                 _ => {}
-108
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-114
+    }
-115
+}
 impl HttpEmptyPrefixHeadersInput {
     /// 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("hello") {
             builder.specific_header = Some(val.to_string());
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.prefix_headers = Some(map);
-+
+            }
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpEmptyPrefixHeadersInput {
     /// Creates a new builder-style object to manufacture [`HttpEmptyPrefixHeadersInput`](crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersInput).
     pub fn builder() -> crate::operation::http_empty_prefix_headers::builders::HttpEmptyPrefixHeadersInputBuilder {
         crate::operation::http_empty_prefix_headers::builders::HttpEmptyPrefixHeadersInputBuilder::default()
-151
+    }
-152
+}
-153
 /// A builder for [`HttpEmptyPrefixHeadersInput`](crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpEmptyPrefixHeadersInputBuilder {
     pub(crate) prefix_headers: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) specific_header: ::std::option::Option<::std::string::String>,
-160
+}
 impl HttpEmptyPrefixHeadersInputBuilder {
     /// Adds a key-value pair to `prefix_headers`.
     ///
     /// To override the contents of this collection use [`set_prefix_headers`](Self::set_prefix_headers).
     ///
     pub fn prefix_headers(
         mut self,
         k: impl ::std::convert::Into<::std::string::String>,
         v: impl ::std::convert::Into<::std::string::String>,
     ) -> Self {
         let mut hash_map = self.prefix_headers.unwrap_or_default();
         hash_map.insert(k.into(), v.into());
         self.prefix_headers = ::std::option::Option::Some(hash_map);
         self
-175
+    }
     #[allow(missing_docs)] // documentation missing in model

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

@@ -3,3 +152,171 @@

↥ Expand context

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

     "aws.protocoltests.restjson.synthetic",
     "HttpEmptyPrefixHeadersOutput",
 );
 static HTTPEMPTYPREFIXHEADERSOUTPUT_MEMBER_PREFIX_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpEmptyPrefixHeadersOutput$prefixHeaders",
         "aws.protocoltests.restjson.synthetic",
         "HttpEmptyPrefixHeadersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "prefix_headers",
     "prefixHeaders",
 ,
-35
+)
 .with_http_prefix_headers("");
 static HTTPEMPTYPREFIXHEADERSOUTPUT_MEMBER_SPECIFIC_HEADER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpEmptyPrefixHeadersOutput$specificHeader",
         "aws.protocoltests.restjson.synthetic",
         "HttpEmptyPrefixHeadersOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "specific_header",
     "specificHeader",
 ,
-46
+)
 .with_http_header("hello");
 static HTTPEMPTYPREFIXHEADERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPEMPTYPREFIXHEADERSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &HTTPEMPTYPREFIXHEADERSOUTPUT_MEMBER_PREFIX_HEADERS,
         &HTTPEMPTYPREFIXHEADERSOUTPUT_MEMBER_SPECIFIC_HEADER,
     ],
 );
 impl HttpEmptyPrefixHeadersOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPEMPTYPREFIXHEADERSOUTPUT_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpEmptyPrefixHeadersOutput {
     #[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.prefix_headers {
             ser.write_map(
                 &HTTPEMPTYPREFIXHEADERSOUTPUT_MEMBER_PREFIX_HEADERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-73
+                    }
                     Ok(())
                 },
             )?;
-77
+        }
         if let Some(ref val) = self.specific_header {
             ser.write_string(&HTTPEMPTYPREFIXHEADERSOUTPUT_MEMBER_SPECIFIC_HEADER, val)?;
-80
+        }
         Ok(())
-82
+    }
-83
+}
 impl HttpEmptyPrefixHeadersOutput {
     /// 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(&HTTPEMPTYPREFIXHEADERSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPEMPTYPREFIXHEADERSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.prefix_headers = 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(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.prefix_headers = Some(deser.read_string_string_map(member)?);
-102
+                }
                 Some(1) => {
                     builder.specific_header = Some(deser.read_string(member)?);
-105
+                }
                 _ => {}
-107
+            }
             Ok(())
         })?;
         Ok(builder.build())
-111
+    }
-112
+}
 impl HttpEmptyPrefixHeadersOutput {
     /// 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("hello") {
             builder.specific_header = Some(val.to_string());
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.prefix_headers = Some(map);
-+
+            }
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpEmptyPrefixHeadersOutput {
     /// Creates a new builder-style object to manufacture [`HttpEmptyPrefixHeadersOutput`](crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersOutput).
     pub fn builder() -> crate::operation::http_empty_prefix_headers::builders::HttpEmptyPrefixHeadersOutputBuilder {
         crate::operation::http_empty_prefix_headers::builders::HttpEmptyPrefixHeadersOutputBuilder::default()
-146
+    }
-147
+}
-148
 /// A builder for [`HttpEmptyPrefixHeadersOutput`](crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpEmptyPrefixHeadersOutputBuilder {
     pub(crate) prefix_headers: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) specific_header: ::std::option::Option<::std::string::String>,
-155
+}
 impl HttpEmptyPrefixHeadersOutputBuilder {
     /// Adds a key-value pair to `prefix_headers`.
     ///
     /// To override the contents of this collection use [`set_prefix_headers`](Self::set_prefix_headers).
     ///
     pub fn prefix_headers(
         mut self,
         k: impl ::std::convert::Into<::std::string::String>,
         v: impl ::std::convert::Into<::std::string::String>,
     ) -> Self {
         let mut hash_map = self.prefix_headers.unwrap_or_default();
         hash_map.insert(k.into(), v.into());
         self.prefix_headers = ::std::option::Option::Some(hash_map);
         self
-170
+    }
     #[allow(missing_docs)] // documentation missing in model

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

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

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

@@ -110,114 +234,250 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "HttpEnumPayload",
             "Rest Json Protocol",
         ));
-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("HttpEnumPayload")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HttpEnumPayloadEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::http_enum_payload::HttpEnumPayloadError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::http_enum_payload::HttpEnumPayloadError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct HttpEnumPayloadResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpEnumPayloadResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_enum_payload::de_http_enum_payload_http_error(status, headers, body)
             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::http_enum_payload::HttpEnumPayloadError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_enum_payload::de_http_enum_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, HttpEnumPayload::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::http_enum_payload::HttpEnumPayloadOutput::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 HttpEnumPayloadRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpEnumPayloadRequestSerializer {
     #[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::http_enum_payload::HttpEnumPayloadInput>()
             .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::http_enum_payload::HttpEnumPayloadInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/EnumPayload").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut input = input;
         let payload = input.payload.take();
         let mut request = protocol
             .serialize_request(&input, HttpEnumPayload::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         if let ::std::option::Option::Some(payload) = payload {
             *request.body_mut() = ::aws_smithy_types::body::SdkBody::from(payload.as_str().as_bytes().to_vec());
             if !request.headers().contains_key("Content-Type") {
                 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());
-217
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_enum_payload::HttpEnumPayloadInput,
                 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("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 = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_http_enum_payload_input::ser_payload_http_payload(
             input.payload,
         )?);
         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);
-218
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-221
+    }
-222
+}
 #[derive(Debug)]
 struct HttpEnumPayloadEndpointParamsInterceptor;
-225
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpEnumPayloadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpEnumPayloadEndpointParamsInterceptor"
-229
+    }
-230

↧ 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::<HttpEnumPayloadInput>()
             .ok_or("failed to downcast to HttpEnumPayloadInput")?;
-245
         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));

@@ -284,300 +344,370 @@

↥ Expand context

         let expected_output = crate::operation::http_enum_payload::HttpEnumPayloadOutput::builder()
             .set_payload(::std::option::Option::Some(
                 "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "text/plain")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("enumvalue"))
                 .unwrap(),
-311
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-315
         let op = crate::operation::http_enum_payload::HttpEnumPayload::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");
-321
         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("unknown"),
                 )))
             });
             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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_enum_payload::HttpEnumPayloadOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.payload, expected_output.payload, "Unexpected value for `payload`");
-347
+    }
-348
+}
-349
 /// Error type for the `HttpEnumPayloadError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpEnumPayloadError {
     /// 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()`:
-357
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-359
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpEnumPayloadError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-362
+}
 impl HttpEnumPayloadError {
     /// Creates the `HttpEnumPayloadError::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>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

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

@@ -5,5 +109,131 @@

↥ Expand context

 pub struct HttpEnumPayloadInput {
     #[allow(missing_docs)] // documentation missing in model
     pub payload: ::std::option::Option<crate::types::StringEnum>,
-8
+}
 impl HttpEnumPayloadInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn payload(&self) -> ::std::option::Option<&crate::types::StringEnum> {
         self.payload.as_ref()
-13
+    }
-14
+}
 static HTTPENUMPAYLOADINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpEnumPayloadInput",
     "aws.protocoltests.restjson.synthetic",
     "HttpEnumPayloadInput",
 );
 static HTTPENUMPAYLOADINPUT_MEMBER_PAYLOAD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpEnumPayloadInput$payload",
         "aws.protocoltests.restjson.synthetic",
         "HttpEnumPayloadInput",

     ),
     ::aws_smithy_schema::ShapeType::String,
     "payload",
 ,
-29
+)
 .with_http_payload();
 static HTTPENUMPAYLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPENUMPAYLOADINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPENUMPAYLOADINPUT_MEMBER_PAYLOAD],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/EnumPayload", None));
 impl HttpEnumPayloadInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPENUMPAYLOADINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpEnumPayloadInput {
     #[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.payload {
             ser.write_string(&HTTPENUMPAYLOADINPUT_MEMBER_PAYLOAD, val.as_str())?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl HttpEnumPayloadInput {
     /// 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(&HTTPENUMPAYLOADINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPENUMPAYLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.payload = Some(crate::types::StringEnum::from(deser.read_string(member)?.as_str()));
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl HttpEnumPayloadInput {
     /// 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 !body.is_empty() {
             let s = ::std::string::String::from_utf8_lossy(body).into_owned();
             builder.payload = Some(crate::types::StringEnum::from(s.as_str()));
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpEnumPayloadInput {
     /// Creates a new builder-style object to manufacture [`HttpEnumPayloadInput`](crate::operation::http_enum_payload::HttpEnumPayloadInput).
     pub fn builder() -> crate::operation::http_enum_payload::builders::HttpEnumPayloadInputBuilder {
         crate::operation::http_enum_payload::builders::HttpEnumPayloadInputBuilder::default()
-106
+    }
-107
+}
-108
 /// A builder for [`HttpEnumPayloadInput`](crate::operation::http_enum_payload::HttpEnumPayloadInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpEnumPayloadInputBuilder {
     pub(crate) payload: ::std::option::Option<crate::types::StringEnum>,
-114
+}
 impl HttpEnumPayloadInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn payload(mut self, input: crate::types::StringEnum) -> Self {
         self.payload = ::std::option::Option::Some(input);
         self
-120
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_payload(mut self, input: ::std::option::Option<crate::types::StringEnum>) -> Self {
         self.payload = input;
         self
-125
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_payload(&self) -> &::std::option::Option<crate::types::StringEnum> {
         &self.payload
-129
+    }
     /// Consumes the builder and constructs a [`HttpEnumPayloadInput`](crate::operation::http_enum_payload::HttpEnumPayloadInput).
     pub fn build(

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

@@ -24,24 +107,126 @@

↥ Expand context

         "HttpEnumPayloadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "payload",
 ,
-29
+)
 .with_http_payload();
 static HTTPENUMPAYLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPENUMPAYLOADOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPENUMPAYLOADOUTPUT_MEMBER_PAYLOAD],
 );
 impl HttpEnumPayloadOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPENUMPAYLOADOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpEnumPayloadOutput {
     #[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.payload {
             ser.write_string(&HTTPENUMPAYLOADOUTPUT_MEMBER_PAYLOAD, val.as_str())?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl HttpEnumPayloadOutput {
     /// 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(&HTTPENUMPAYLOADOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPENUMPAYLOADOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.payload = Some(crate::types::StringEnum::from(deser.read_string(member)?.as_str()));
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl HttpEnumPayloadOutput {
     /// 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 !body.is_empty() {
             let s = ::std::string::String::from_utf8_lossy(body).into_owned();
             builder.payload = Some(crate::types::StringEnum::from(s.as_str()));
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpEnumPayloadOutput {
     /// Creates a new builder-style object to manufacture [`HttpEnumPayloadOutput`](crate::operation::http_enum_payload::HttpEnumPayloadOutput).
     pub fn builder() -> crate::operation::http_enum_payload::builders::HttpEnumPayloadOutputBuilder {
         crate::operation::http_enum_payload::builders::HttpEnumPayloadOutputBuilder::default()
-101
+    }
-102
+}
-103
 /// A builder for [`HttpEnumPayloadOutput`](crate::operation::http_enum_payload::HttpEnumPayloadOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpEnumPayloadOutputBuilder {
     pub(crate) payload: ::std::option::Option<crate::types::StringEnum>,
-109
+}
 impl HttpEnumPayloadOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn payload(mut self, input: crate::types::StringEnum) -> Self {
         self.payload = ::std::option::Option::Some(input);
         self
-115
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_payload(mut self, input: ::std::option::Option<crate::types::StringEnum>) -> Self {
         self.payload = input;
         self
-120
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_payload(&self) -> &::std::option::Option<crate::types::StringEnum> {
         &self.payload
-124
+    }
     /// Consumes the builder and constructs a [`HttpEnumPayloadOutput`](crate::operation::http_enum_payload::HttpEnumPayloadOutput).
     pub fn build(self) -> crate::operation::http_enum_payload::HttpEnumPayloadOutput {

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/http_payload_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 `HttpPayloadTraits`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct HttpPayloadTraits;
 impl HttpPayloadTraits {
     /// Creates a new `HttpPayloadTraits`
     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::http_payload_traits::HttpPayloadTraitsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::http_payload_traits::HttpPayloadTraitsInput,
     ) -> ::std::result::Result<
         crate::operation::http_payload_traits::HttpPayloadTraitsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::http_payload_traits::HttpPayloadTraitsError,
             ::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::http_payload_traits::HttpPayloadTraitsError>()
                     .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::http_payload_traits::HttpPayloadTraitsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -110,114 +234,250 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "HttpPayloadTraits",
             "Rest Json Protocol",
         ));
-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("HttpPayloadTraits")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HttpPayloadTraitsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::http_payload_traits::HttpPayloadTraitsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::http_payload_traits::HttpPayloadTraitsError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct HttpPayloadTraitsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpPayloadTraitsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_payload_traits::de_http_payload_traits_http_error(status, headers, body)
             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::http_payload_traits::HttpPayloadTraitsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_payload_traits::de_http_payload_traits_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, HttpPayloadTraits::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::http_payload_traits::HttpPayloadTraitsOutput::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 HttpPayloadTraitsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpPayloadTraitsRequestSerializer {
     #[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::http_payload_traits::HttpPayloadTraitsInput>()
             .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::http_payload_traits::HttpPayloadTraitsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/HttpPayloadTraits").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut input = input;
         let payload = input.blob.take();
         let mut request = protocol
             .serialize_request(&input, HttpPayloadTraits::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         if let ::std::option::Option::Some(payload) = payload {
             *request.body_mut() = ::aws_smithy_types::body::SdkBody::from(payload.into_inner());
             if !request.headers().contains_key("Content-Type") {
                 request.headers_mut().insert("Content-Type", "application/octet-stream");
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_payload_traits::HttpPayloadTraitsInput,
                 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_http_payload_traits::ser_http_payload_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 =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_http_payload_traits_input::ser_blob_http_payload(input.blob)?);
         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);
             if let ::std::option::Option::Some(content_length) = request.body().content_length() {
                 request.headers_mut().insert("Content-Length", content_length.to_string());
-217
+            }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
+        }
-+
         return ::std::result::Result::Ok(request);
-221
+    }
-222
+}
 #[derive(Debug)]
 struct HttpPayloadTraitsEndpointParamsInterceptor;
-225
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadTraitsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadTraitsEndpointParamsInterceptor"
-229
+    }
-230

↧ 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::<HttpPayloadTraitsInput>()
             .ok_or("failed to downcast to HttpPayloadTraitsInput")?;
-245
         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));

@@ -318,334 +421,457 @@

↥ Expand context

     async fn rest_json_http_payload_traits_with_blob_response() {
         let expected_output = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::builder()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")))
             .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("blobby blob blob"))
                 .unwrap(),
-345
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-349
         let op = crate::operation::http_payload_traits::HttpPayloadTraits::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");
-355
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_traits::HttpPayloadTraitsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(parsed.blob, expected_output.blob, "Unexpected value for `blob`");
-382
+    }
-383
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_no_blob_body_response() {
         let expected_output = crate::operation::http_payload_traits::HttpPayloadTraitsOutput::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(),
-398
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-402
         let op = crate::operation::http_payload_traits::HttpPayloadTraits::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");
-408
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_traits::HttpPayloadTraitsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(parsed.blob, expected_output.blob, "Unexpected value for `blob`");
-435
+    }
-436
+}
-437

↧ Expand context

 /// Error type for the `HttpPayloadTraitsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpPayloadTraitsError {
     /// 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()`:
-445
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-447
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpPayloadTraitsError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-450
+}
 impl HttpPayloadTraitsError {
     /// Creates the `HttpPayloadTraitsError::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>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),

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

@@ -22,22 +132,156 @@

↥ Expand context

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

     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
 ,
-46
+)
 .with_http_payload();
 static HTTPPAYLOADTRAITSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADTRAITSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADTRAITSINPUT_MEMBER_FOO, &HTTPPAYLOADTRAITSINPUT_MEMBER_BLOB],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/HttpPayloadTraits", None));
 impl HttpPayloadTraitsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADTRAITSINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadTraitsInput {
     #[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(&HTTPPAYLOADTRAITSINPUT_MEMBER_FOO, val)?;
-66
+        }
         if let Some(ref val) = self.blob {
             ser.write_blob(&HTTPPAYLOADTRAITSINPUT_MEMBER_BLOB, val)?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl HttpPayloadTraitsInput {
     /// 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(&HTTPPAYLOADTRAITSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADTRAITSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-91
+                }
                 Some(1) => {
                     builder.blob = Some(deser.read_blob(member)?);
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-102
+    }
-103
+}
 impl HttpPayloadTraitsInput {
     /// 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());
-+
+        }
         if !body.is_empty() {
             builder.blob = Some(::aws_smithy_types::Blob::new(body.to_vec()));
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpPayloadTraitsInput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadTraitsInput`](crate::operation::http_payload_traits::HttpPayloadTraitsInput).
     pub fn builder() -> crate::operation::http_payload_traits::builders::HttpPayloadTraitsInputBuilder {
         crate::operation::http_payload_traits::builders::HttpPayloadTraitsInputBuilder::default()
-131
+    }
-132
+}
-133
 /// A builder for [`HttpPayloadTraitsInput`](crate::operation::http_payload_traits::HttpPayloadTraitsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadTraitsInputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
-140
+}
 impl HttpPayloadTraitsInputBuilder {
     #[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
-146
+    }
     #[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
-151
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-155
+    }
     #[allow(missing_docs)] // documentation missing in model

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

@@ -44,44 +130,151 @@

↥ Expand context

     "blob",
 ,
-46
+)
 .with_http_payload();
 static HTTPPAYLOADTRAITSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADTRAITSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADTRAITSOUTPUT_MEMBER_FOO, &HTTPPAYLOADTRAITSOUTPUT_MEMBER_BLOB],
 );
 impl HttpPayloadTraitsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADTRAITSOUTPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadTraitsOutput {
     #[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(&HTTPPAYLOADTRAITSOUTPUT_MEMBER_FOO, val)?;
-65
+        }
         if let Some(ref val) = self.blob {
             ser.write_blob(&HTTPPAYLOADTRAITSOUTPUT_MEMBER_BLOB, val)?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl HttpPayloadTraitsOutput {
     /// 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(&HTTPPAYLOADTRAITSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADTRAITSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-90
+                }
                 Some(1) => {
                     builder.blob = Some(deser.read_blob(member)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         Ok(builder.build())
-99
+    }
-100
+}
 impl HttpPayloadTraitsOutput {
     /// 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());
-+
+        }
         if !body.is_empty() {
             builder.blob = Some(::aws_smithy_types::Blob::new(body.to_vec()));
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPayloadTraitsOutput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadTraitsOutput`](crate::operation::http_payload_traits::HttpPayloadTraitsOutput).
     pub fn builder() -> crate::operation::http_payload_traits::builders::HttpPayloadTraitsOutputBuilder {
         crate::operation::http_payload_traits::builders::HttpPayloadTraitsOutputBuilder::default()
-126
+    }
-127
+}
-128
 /// A builder for [`HttpPayloadTraitsOutput`](crate::operation::http_payload_traits::HttpPayloadTraitsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadTraitsOutputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
-135
+}
 impl HttpPayloadTraitsOutputBuilder {
     #[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
-141
+    }
     #[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
-146
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-150
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/http_payload_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 `HttpPayloadTraitsWithMediaType`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct HttpPayloadTraitsWithMediaType;
 impl HttpPayloadTraitsWithMediaType {
     /// Creates a new `HttpPayloadTraitsWithMediaType`
     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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput,
     ) -> ::std::result::Result<
         crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError,
             ::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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError>()
                     .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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -110,116 +239,252 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "HttpPayloadTraitsWithMediaType",
             "Rest Json Protocol",
         ));
-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("HttpPayloadTraitsWithMediaType")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct HttpPayloadTraitsWithMediaTypeResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpPayloadTraitsWithMediaTypeResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_type_http_error(status, headers, body)
             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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_type_http_response(
                 status, headers, body,
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, HttpPayloadTraitsWithMediaType::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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-184
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
             .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 HttpPayloadTraitsWithMediaTypeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpPayloadTraitsWithMediaTypeRequestSerializer {
     #[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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput>()
             .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::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/HttpPayloadTraitsWithMediaType").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut input = input;
         let payload = input.blob.take();
         let mut request = protocol
             .serialize_request(&input, HttpPayloadTraitsWithMediaType::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         if let ::std::option::Option::Some(payload) = payload {
             *request.body_mut() = ::aws_smithy_types::body::SdkBody::from(payload.into_inner());
             if !request.headers().contains_key("Content-Type") {
                 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());
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput,
                 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_http_payload_traits_with_media_type::ser_http_payload_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 = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_http_payload_traits_with_media_type_input::ser_blob_http_payload(input.blob)?,
         );
         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);
-220
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-223
+    }
-224
+}
 #[derive(Debug)]
 struct HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor;
-227
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadTraitsWithMediaTypeEndpointParamsInterceptor"
-231
+    }
-232

↧ 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::<HttpPayloadTraitsWithMediaTypeInput>()
             .ok_or("failed to downcast to HttpPayloadTraitsWithMediaTypeInput")?;
-247
         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));

@@ -293,306 +353,376 @@

↥ Expand context

         let expected_output = crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput::builder()
             .set_foo(::std::option::Option::Some("Foo".to_owned()))
             .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("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(),
-317
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-321
         let op = crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaType::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");
-327
         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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(parsed.blob, expected_output.blob, "Unexpected value for `blob`");
-354
+    }
-355
+}
-356

↧ Expand context

 /// Error type for the `HttpPayloadTraitsWithMediaTypeError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpPayloadTraitsWithMediaTypeError {
     /// 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()`:
-364
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-366
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpPayloadTraitsWithMediaTypeError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-369
+}
 impl HttpPayloadTraitsWithMediaTypeError {
     /// Creates the `HttpPayloadTraitsWithMediaTypeError::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>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),

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

@@ -17,17 +135,160 @@

↥ Expand context

     pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
         self.blob.as_ref()
-19
+    }
-20
+}
 static HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPayloadTraitsWithMediaTypeInput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPayloadTraitsWithMediaTypeInput",
 );
 static HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadTraitsWithMediaTypeInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadTraitsWithMediaTypeInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
-35
+)
 .with_http_header("X-Foo");

 static HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadTraitsWithMediaTypeInput$blob",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadTraitsWithMediaTypeInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
 ,
-46
+)
 .with_http_payload();
 .with_http_payload()
 .with_media_type("text/plain");
 static HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_MEMBER_FOO,
         &HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_MEMBER_BLOB,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/HttpPayloadTraitsWithMediaType", None));
 impl HttpPayloadTraitsWithMediaTypeInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadTraitsWithMediaTypeInput {
     #[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(&HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_MEMBER_FOO, val)?;
-70
+        }
         if let Some(ref val) = self.blob {
             ser.write_blob(&HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_MEMBER_BLOB, val)?;
-73
+        }
         Ok(())
-75
+    }
-76
+}
 impl HttpPayloadTraitsWithMediaTypeInput {
     /// 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(&HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADTRAITSWITHMEDIATYPEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-95
+                }
                 Some(1) => {
                     builder.blob = Some(deser.read_blob(member)?);
-98
+                }
                 _ => {}
-100
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-106
+    }
-107
+}
 impl HttpPayloadTraitsWithMediaTypeInput {
     /// 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());
-+
+        }
         if !body.is_empty() {
             builder.blob = Some(::aws_smithy_types::Blob::new(body.to_vec()));
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpPayloadTraitsWithMediaTypeInput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadTraitsWithMediaTypeInput`](crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput).
     pub fn builder() -> crate::operation::http_payload_traits_with_media_type::builders::HttpPayloadTraitsWithMediaTypeInputBuilder {
         crate::operation::http_payload_traits_with_media_type::builders::HttpPayloadTraitsWithMediaTypeInputBuilder::default()
-135
+    }
-136
+}
-137
 /// A builder for [`HttpPayloadTraitsWithMediaTypeInput`](crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadTraitsWithMediaTypeInputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
-144
+}
 impl HttpPayloadTraitsWithMediaTypeInputBuilder {
     #[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
-150
+    }
     #[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
-155
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-159
+    }
     #[allow(missing_docs)] // documentation missing in model

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

@@ -17,17 +133,155 @@

↥ Expand context

     pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
         self.blob.as_ref()
-19
+    }
-20
+}
 static HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPayloadTraitsWithMediaTypeOutput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPayloadTraitsWithMediaTypeOutput",
 );
 static HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadTraitsWithMediaTypeOutput$foo",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadTraitsWithMediaTypeOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
-35
+)
 .with_http_header("X-Foo");

 static HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_MEMBER_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadTraitsWithMediaTypeOutput$blob",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadTraitsWithMediaTypeOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "blob",
 ,
-46
+)
 .with_http_payload();
 .with_http_payload()
 .with_media_type("text/plain");
 static HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_MEMBER_FOO,
         &HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_MEMBER_BLOB,
     ],
 );
 impl HttpPayloadTraitsWithMediaTypeOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadTraitsWithMediaTypeOutput {
     #[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(&HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_MEMBER_FOO, val)?;
-69
+        }
         if let Some(ref val) = self.blob {
             ser.write_blob(&HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_MEMBER_BLOB, val)?;
-72
+        }
         Ok(())
-74
+    }
-75
+}
 impl HttpPayloadTraitsWithMediaTypeOutput {
     /// 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(&HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADTRAITSWITHMEDIATYPEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-94
+                }
                 Some(1) => {
                     builder.blob = Some(deser.read_blob(member)?);
-97
+                }
                 _ => {}
-99
+            }
             Ok(())
         })?;
         Ok(builder.build())
-103
+    }
-104
+}
 impl HttpPayloadTraitsWithMediaTypeOutput {
     /// 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());
-+
+        }
         if !body.is_empty() {
             builder.blob = Some(::aws_smithy_types::Blob::new(body.to_vec()));
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPayloadTraitsWithMediaTypeOutput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadTraitsWithMediaTypeOutput`](crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput).
     pub fn builder() -> crate::operation::http_payload_traits_with_media_type::builders::HttpPayloadTraitsWithMediaTypeOutputBuilder {
         crate::operation::http_payload_traits_with_media_type::builders::HttpPayloadTraitsWithMediaTypeOutputBuilder::default()
-130
+    }
-131
+}
-132
 /// A builder for [`HttpPayloadTraitsWithMediaTypeOutput`](crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadTraitsWithMediaTypeOutputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
-139
+}
 impl HttpPayloadTraitsWithMediaTypeOutputBuilder {
     #[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
-145
+    }
     #[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
-150
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-154
+    }
     #[allow(missing_docs)] // documentation missing in model

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

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

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

@@ -110,116 +234,241 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "HttpPayloadWithStructure",
             "Rest Json Protocol",
         ));
-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("HttpPayloadWithStructure")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(HttpPayloadWithStructureEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::http_payload_with_structure::HttpPayloadWithStructureError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::http_payload_with_structure::HttpPayloadWithStructureError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct HttpPayloadWithStructureResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpPayloadWithStructureResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_structure_http_error(status, headers, body)
             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::http_payload_with_structure::HttpPayloadWithStructureError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_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, HttpPayloadWithStructure::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::http_payload_with_structure::HttpPayloadWithStructureOutput::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 HttpPayloadWithStructureRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpPayloadWithStructureRequestSerializer {
     #[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::http_payload_with_structure::HttpPayloadWithStructureInput>()
             .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::http_payload_with_structure::HttpPayloadWithStructureInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/HttpPayloadWithStructure").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_payload_with_structure::HttpPayloadWithStructureInput,
                 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("PUT").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/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_http_payload_with_structure_input::ser_nested_http_payload(
             &input.nested,
         )?);
         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);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, HttpPayloadWithStructure::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct HttpPayloadWithStructureEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPayloadWithStructureEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPayloadWithStructureEndpointParamsInterceptor"
-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::<HttpPayloadWithStructureInput>()
             .ok_or("failed to downcast to HttpPayloadWithStructureInput")?;
-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));

@@ -297,304 +398,425 @@

↥ Expand context

                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}",
                 ))
                 .unwrap(),
-315
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-319
         let op = crate::operation::http_payload_with_structure::HttpPayloadWithStructure::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");
-325
         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/json"),
                 )))
             });
             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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-351
+    }
-352
     /// Serializes a structure in the payload
     /// Test ID: RestJsonHttpPayloadWithStructureAndEmptyResponseBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_structure_and_empty_response_body_response() {
         let expected_output = crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput::builder()
             .set_nested(::std::option::Option::None)
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-366
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-370
         let op = crate::operation::http_payload_with_structure::HttpPayloadWithStructure::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");
-376
         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("unknown"),
                 )))
             });
             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_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-402
+    }
-403
+}
-404
 /// Error type for the `HttpPayloadWithStructureError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpPayloadWithStructureError {
     /// 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()`:
-412
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-414
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpPayloadWithStructureError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-417
+}
 impl HttpPayloadWithStructureError {
     /// Creates the `HttpPayloadWithStructureError::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>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

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

@@ -5,5 +109,130 @@

↥ Expand context

 pub struct HttpPayloadWithStructureInput {
     #[allow(missing_docs)] // documentation missing in model
     pub nested: ::std::option::Option<crate::types::NestedPayload>,
-8
+}
 impl HttpPayloadWithStructureInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(&self) -> ::std::option::Option<&crate::types::NestedPayload> {
         self.nested.as_ref()
-13
+    }
-14
+}
 static HTTPPAYLOADWITHSTRUCTUREINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPayloadWithStructureInput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPayloadWithStructureInput",
 );
 static HTTPPAYLOADWITHSTRUCTUREINPUT_MEMBER_NESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadWithStructureInput$nested",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadWithStructureInput",

     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "nested",
 ,
-29
+)
 .with_http_payload();
 static HTTPPAYLOADWITHSTRUCTUREINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADWITHSTRUCTUREINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADWITHSTRUCTUREINPUT_MEMBER_NESTED],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/HttpPayloadWithStructure", None));
 impl HttpPayloadWithStructureInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADWITHSTRUCTUREINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadWithStructureInput {
     #[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.nested {
             ser.write_struct(&HTTPPAYLOADWITHSTRUCTUREINPUT_MEMBER_NESTED, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl HttpPayloadWithStructureInput {
     /// 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(&HTTPPAYLOADWITHSTRUCTUREINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADWITHSTRUCTUREINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nested = Some(crate::types::NestedPayload::deserialize(deser)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl HttpPayloadWithStructureInput {
     /// 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 !body.is_empty() {
             builder.nested = Some(crate::types::NestedPayload::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpPayloadWithStructureInput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadWithStructureInput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureInput).
     pub fn builder() -> crate::operation::http_payload_with_structure::builders::HttpPayloadWithStructureInputBuilder {
         crate::operation::http_payload_with_structure::builders::HttpPayloadWithStructureInputBuilder::default()
-105
+    }
-106
+}
-107
 /// A builder for [`HttpPayloadWithStructureInput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadWithStructureInputBuilder {
     pub(crate) nested: ::std::option::Option<crate::types::NestedPayload>,
-113
+}
 impl HttpPayloadWithStructureInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(mut self, input: crate::types::NestedPayload) -> Self {
         self.nested = ::std::option::Option::Some(input);
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_nested(mut self, input: ::std::option::Option<crate::types::NestedPayload>) -> Self {
         self.nested = input;
         self
-124
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_nested(&self) -> &::std::option::Option<crate::types::NestedPayload> {
         &self.nested
-128
+    }
     /// Consumes the builder and constructs a [`HttpPayloadWithStructureInput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureInput).
     pub fn build(

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

@@ -24,24 +107,125 @@

↥ Expand context

         "HttpPayloadWithStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "nested",
 ,
-29
+)
 .with_http_payload();
 static HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADWITHSTRUCTUREOUTPUT_MEMBER_NESTED],
 );
 impl HttpPayloadWithStructureOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadWithStructureOutput {
     #[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.nested {
             ser.write_struct(&HTTPPAYLOADWITHSTRUCTUREOUTPUT_MEMBER_NESTED, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl HttpPayloadWithStructureOutput {
     /// 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(&HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nested = Some(crate::types::NestedPayload::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl HttpPayloadWithStructureOutput {
     /// 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 !body.is_empty() {
             builder.nested = Some(crate::types::NestedPayload::deserialize(deserializer)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPayloadWithStructureOutput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadWithStructureOutput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput).
     pub fn builder() -> crate::operation::http_payload_with_structure::builders::HttpPayloadWithStructureOutputBuilder {
         crate::operation::http_payload_with_structure::builders::HttpPayloadWithStructureOutputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`HttpPayloadWithStructureOutput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadWithStructureOutputBuilder {
     pub(crate) nested: ::std::option::Option<crate::types::NestedPayload>,
-108
+}
 impl HttpPayloadWithStructureOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(mut self, input: crate::types::NestedPayload) -> Self {
         self.nested = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_nested(mut self, input: ::std::option::Option<crate::types::NestedPayload>) -> Self {
         self.nested = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_nested(&self) -> &::std::option::Option<crate::types::NestedPayload> {
         &self.nested
-123
+    }
     /// Consumes the builder and constructs a [`HttpPayloadWithStructureOutput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput).
     pub fn build(self) -> crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput {

Client Test

Files changed: