Client Test

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/case_insensitive_error_operation.rs

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

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

@@ -113,119 +228,306 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct CaseInsensitiveErrorOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CaseInsensitiveErrorOperationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "CaseInsensitiveError" => {
                     crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::CaseInsensitiveError({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::CaseInsensitiveError::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::CaseInsensitiveError::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "ExtraError" => crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::ExtraError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ExtraError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ExtraError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_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, CaseInsensitiveErrorOperation::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::case_insensitive_error_operation::CaseInsensitiveErrorOperationOutput::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))
-+
+        }
-255
+    }
-256
+}
 #[derive(Debug)]
 struct CaseInsensitiveErrorOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CaseInsensitiveErrorOperationRequestSerializer {
     #[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::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput>()
             .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::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/error-sensitive").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput,
                 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
         };
         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, CaseInsensitiveErrorOperation::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-275
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-277
+    }
-278
+}
 #[derive(Debug)]
 struct CaseInsensitiveErrorOperationEndpointParamsInterceptor;
-281
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CaseInsensitiveErrorOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CaseInsensitiveErrorOperationEndpointParamsInterceptor"
-285
+    }
-286

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

@@ -243,321 +346,444 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn upper_error_modeled_lower_response() {
         let expected_output = crate::types::error::CaseInsensitiveError::builder()
             .set_message(::std::option::Option::Some("hello".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "CaseInsensitiveError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from("{\"Message\": \"hello\"}"))
                 .unwrap(),
-332
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-336
         let op = crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperation::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");
-342
         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(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::CaseInsensitiveError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-370
+        }
-371
+    }
-372
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-385
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-389
         let op = crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperation::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");
-395
         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(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::ExtraError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-423
+        }
-424
+    }

↧ Expand context

-425
+}
-426
 /// Error type for the `CaseInsensitiveErrorOperationError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum CaseInsensitiveErrorOperationError {
     #[allow(missing_docs)] // documentation missing in model
     CaseInsensitiveError(crate::types::error::CaseInsensitiveError),
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::types::error::ExtraError),
     /// 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()`:
-438
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-440
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-CaseInsensitiveErrorOperationError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-443
+}
 impl CaseInsensitiveErrorOperationError {

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/case_insensitive_error_operation/_case_insensitive_error_operation_input.rs

@@ -1,1 +75,89 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

 pub struct CaseInsensitiveErrorOperationInput {}
 static CASEINSENSITIVEERROROPERATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#CaseInsensitiveErrorOperationInput",
     "aws.protocoltests.restjson.synthetic",
     "CaseInsensitiveErrorOperationInput",
 );
 static CASEINSENSITIVEERROROPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CASEINSENSITIVEERROROPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/error-sensitive", None));
 impl CaseInsensitiveErrorOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CASEINSENSITIVEERROROPERATIONINPUT_SCHEMA;
-20
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CaseInsensitiveErrorOperationInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-28
+    }
-29
+}
 impl CaseInsensitiveErrorOperationInput {
     /// 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(&CASEINSENSITIVEERROROPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CASEINSENSITIVEERROROPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-47
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-53
+    }
-54
+}
 impl CaseInsensitiveErrorOperationInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CaseInsensitiveErrorOperationInput {
     /// Creates a new builder-style object to manufacture [`CaseInsensitiveErrorOperationInput`](crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput).
     pub fn builder() -> crate::operation::case_insensitive_error_operation::builders::CaseInsensitiveErrorOperationInputBuilder {
         crate::operation::case_insensitive_error_operation::builders::CaseInsensitiveErrorOperationInputBuilder::default()
-72
+    }
-73
+}
-74
 /// A builder for [`CaseInsensitiveErrorOperationInput`](crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CaseInsensitiveErrorOperationInputBuilder {}
 impl CaseInsensitiveErrorOperationInputBuilder {
     /// Consumes the builder and constructs a [`CaseInsensitiveErrorOperationInput`](crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<
         crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput,
         ::aws_smithy_types::error::operation::BuildError,
     > {
         ::std::result::Result::Ok(crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationInput {})
-88
+    }
-89
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/case_insensitive_error_operation/_case_insensitive_error_operation_output.rs

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

↥ Expand context

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

     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-27
+    }
-28
+}
 impl CaseInsensitiveErrorOperationOutput {
     /// 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(&CASEINSENSITIVEERROROPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CASEINSENSITIVEERROROPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-46
+            }
             Ok(())
         })?;
         Ok(builder.build())
-50
+    }
-51
+}
 impl CaseInsensitiveErrorOperationOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Ok(Self::builder().build())
-+
+    }
-+
+}
 impl CaseInsensitiveErrorOperationOutput {
     /// Creates a new builder-style object to manufacture [`CaseInsensitiveErrorOperationOutput`](crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationOutput).
     pub fn builder() -> crate::operation::case_insensitive_error_operation::builders::CaseInsensitiveErrorOperationOutputBuilder {
         crate::operation::case_insensitive_error_operation::builders::CaseInsensitiveErrorOperationOutputBuilder::default()
-67
+    }
-68
+}
-69
 /// A builder for [`CaseInsensitiveErrorOperationOutput`](crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/empty_struct_with_content_on_wire_op.rs

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

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

@@ -113,119 +232,280 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct EmptyStructWithContentOnWireOpResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for EmptyStructWithContentOnWireOpResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_error(
                 status, headers, body,
--
+            )
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "ExtraError" => crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::ExtraError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ExtraError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ExtraError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_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, EmptyStructWithContentOnWireOp::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::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-223
+            )
         };
         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))
-+
+        }
-229
+    }
-230
+}
 #[derive(Debug)]
 struct EmptyStructWithContentOnWireOpRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for EmptyStructWithContentOnWireOpRequestSerializer {
     #[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::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput>()
             .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::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/empty-struct-with-content-on-wire-op").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, EmptyStructWithContentOnWireOp::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-249
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-251
+    }
-252
+}
 #[derive(Debug)]
 struct EmptyStructWithContentOnWireOpEndpointParamsInterceptor;
-255
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EmptyStructWithContentOnWireOpEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EmptyStructWithContentOnWireOpEndpointParamsInterceptor"
-259
+    }
-260

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

@@ -245,293 +345,413 @@

↥ Expand context

     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn empty_struct_with_content_on_wire_response() {
         let expected_output = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput::builder()
             .set_empty(::std::option::Option::Some(crate::types::EmptyStruct::builder().build()))
             .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("{\"empty\": {\"value\":\"not actually empty\"}}"))
                 .unwrap(),
-304
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-308
         let op = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOp::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");
-314
         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(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.empty, expected_output.empty, "Unexpected value for `empty`");
-340
+    }
-341
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-354
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-358
         let op = crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOp::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");
-364
         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(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::ExtraError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-392
+        }
-393
+    }

↧ Expand context

-394
+}
-395
 /// Error type for the `EmptyStructWithContentOnWireOpError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EmptyStructWithContentOnWireOpError {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::types::error::ExtraError),
     /// 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()`:
-405
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-407
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EmptyStructWithContentOnWireOpError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-410
+}
 impl EmptyStructWithContentOnWireOpError {
     /// Creates the `EmptyStructWithContentOnWireOpError::Unhandled` variant from any error type.
     pub fn unhandled(

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/empty_struct_with_content_on_wire_op/_empty_struct_with_content_on_wire_op_input.rs

@@ -1,1 +75,93 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

 pub struct EmptyStructWithContentOnWireOpInput {}
 static EMPTYSTRUCTWITHCONTENTONWIREOPINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#EmptyStructWithContentOnWireOpInput",
     "aws.protocoltests.restjson.synthetic",
     "EmptyStructWithContentOnWireOpInput",
 );
 static EMPTYSTRUCTWITHCONTENTONWIREOPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     EMPTYSTRUCTWITHCONTENTONWIREOPINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/empty-struct-with-content-on-wire-op",
     None,
 ));
 impl EmptyStructWithContentOnWireOpInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EMPTYSTRUCTWITHCONTENTONWIREOPINPUT_SCHEMA;
-24
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EmptyStructWithContentOnWireOpInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-32
+    }
-33
+}
 impl EmptyStructWithContentOnWireOpInput {
     /// 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(&EMPTYSTRUCTWITHCONTENTONWIREOPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&EMPTYSTRUCTWITHCONTENTONWIREOPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-51
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-57
+    }
-58
+}
 impl EmptyStructWithContentOnWireOpInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl EmptyStructWithContentOnWireOpInput {
     /// Creates a new builder-style object to manufacture [`EmptyStructWithContentOnWireOpInput`](crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput).
     pub fn builder() -> crate::operation::empty_struct_with_content_on_wire_op::builders::EmptyStructWithContentOnWireOpInputBuilder {
         crate::operation::empty_struct_with_content_on_wire_op::builders::EmptyStructWithContentOnWireOpInputBuilder::default()
-76
+    }
-77
+}
-78
 /// A builder for [`EmptyStructWithContentOnWireOpInput`](crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EmptyStructWithContentOnWireOpInputBuilder {}
 impl EmptyStructWithContentOnWireOpInputBuilder {
     /// Consumes the builder and constructs a [`EmptyStructWithContentOnWireOpInput`](crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<
         crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput,
         ::aws_smithy_types::error::operation::BuildError,
     > {
         ::std::result::Result::Ok(crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpInput {})
-92
+    }
-93
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/empty_struct_with_content_on_wire_op/_empty_struct_with_content_on_wire_op_output.rs

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

↥ Expand context

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

↧ Expand context

 pub struct EmptyStructWithContentOnWireOpOutputBuilder {
     pub(crate) empty: ::std::option::Option<crate::types::EmptyStruct>,
-100
+}
 impl EmptyStructWithContentOnWireOpOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn empty(mut self, input: crate::types::EmptyStruct) -> Self {
         self.empty = ::std::option::Option::Some(input);
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_empty(mut self, input: ::std::option::Option<crate::types::EmptyStruct>) -> Self {
         self.empty = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_empty(&self) -> &::std::option::Option<crate::types::EmptyStruct> {
         &self.empty
-115
+    }
     /// Consumes the builder and constructs a [`EmptyStructWithContentOnWireOpOutput`](crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput).
     pub fn build(self) -> crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput {

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/enum_query.rs

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

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

@@ -107,111 +231,317 @@

↥ Expand context

         ));
-112
         ::std::option::Option::Some(cfg.freeze())
-114
+    }
-115
     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("EnumQuery")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(EnumQueryEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::enum_query::EnumQueryError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::enum_query::EnumQueryError,
             >::new());
-130

         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct EnumQueryResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for EnumQueryResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-146
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_enum_query::de_enum_query_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::enum_query::EnumQueryError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "ValidationException" => crate::operation::enum_query::EnumQueryError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     tmp
                 }),
                 "ExtraError" => crate::operation::enum_query::EnumQueryError::ExtraError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ExtraError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ExtraError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::enum_query::EnumQueryError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_enum_query::de_enum_query_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, EnumQuery::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::enum_query::EnumQueryOutput::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))
-+
+        }
-238
+    }
-239
+}
 #[derive(Debug)]
 struct EnumQueryRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for EnumQueryRequestSerializer {
     #[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::enum_query::EnumQueryInput>().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::enum_query::EnumQueryInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.r#enum;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("r#enum", "cannot be empty or unset"))?;
                 let r#enum = ::aws_smithy_http::label::fmt_string(input_1.as_str(), ::aws_smithy_http::label::EncodingStrategy::Default);
                 if r#enum.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "r#enum",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, EnumQuery::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/foo/{enum}".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.r#enum {
                     uri = uri.replace("{enum}", &::aws_smithy_schema::http_protocol::percent_encode(&val.as_str()));
-262
+                }
                 ::std::write!(output, "/foo/{enum}", enum = r#enum).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::enum_query::EnumQueryInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-278
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-279
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, EnumQuery::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-288
+    }
-289
+}
 #[derive(Debug)]
 struct EnumQueryEndpointParamsInterceptor;
-292
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EnumQueryEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EnumQueryEndpointParamsInterceptor"
-296
+    }
-297

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

@@ -271,357 +331,427 @@

↥ Expand context

     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-368
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-372
         let op = crate::operation::enum_query::EnumQuery::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");
-378
         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(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::enum_query::EnumQueryError = parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::enum_query::EnumQueryError::ExtraError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-405
+        }
-406
+    }
-407
+}

↧ Expand context

-408
 /// Error type for the `EnumQueryError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EnumQueryError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationError(crate::types::error::ValidationError),
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::types::error::ExtraError),
     /// 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()`:
-420
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-422
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EnumQueryError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-425
+}
 impl EnumQueryError {
     /// Creates the `EnumQueryError::Unhandled` variant from any error type.

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/enum_query/_enum_query_input.rs

@@ -1,1 +109,121 @@

↥ Expand context

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

     "aws.protocoltests.restjson.synthetic",
     "EnumQueryInput",
 );
 static ENUMQUERYINPUT_MEMBER_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#EnumQueryInput$enum",
         "aws.protocoltests.restjson.synthetic",
         "EnumQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##enum",
     "enum",
 ,
-29
+)
 .with_http_label();
 static ENUMQUERYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ENUMQUERYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ENUMQUERYINPUT_MEMBER_ENUM],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/foo/{enum}", None));
 impl EnumQueryInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENUMQUERYINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EnumQueryInput {
     #[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.r#enum {
             ser.write_string(&ENUMQUERYINPUT_MEMBER_ENUM, val.as_str())?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl EnumQueryInput {
     /// 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(&ENUMQUERYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ENUMQUERYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.r#enum = 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 EnumQueryInput {
     /// 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 EnumQueryInput {
     /// Creates a new builder-style object to manufacture [`EnumQueryInput`](crate::operation::enum_query::EnumQueryInput).
     pub fn builder() -> crate::operation::enum_query::builders::EnumQueryInputBuilder {
         crate::operation::enum_query::builders::EnumQueryInputBuilder::default()
-96
+    }
-97
+}
-98
 /// A builder for [`EnumQueryInput`](crate::operation::enum_query::EnumQueryInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EnumQueryInputBuilder {
     pub(crate) r#enum: ::std::option::Option<crate::types::StringEnum>,
-104
+}
 impl EnumQueryInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn r#enum(mut self, input: crate::types::StringEnum) -> Self {
         self.r#enum = ::std::option::Option::Some(input);
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_enum(mut self, input: ::std::option::Option<crate::types::StringEnum>) -> Self {
         self.r#enum = input;
         self
-116
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_enum(&self) -> &::std::option::Option<crate::types::StringEnum> {
         &self.r#enum
-120
+    }
     /// Consumes the builder and constructs a [`EnumQueryInput`](crate::operation::enum_query::EnumQueryInput).

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/enum_query/_enum_query_output.rs

@@ -1,1 +65,76 @@

↥ Expand context

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

     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-24
+    }
-25
+}
 impl EnumQueryOutput {
     /// 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(&ENUMQUERYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ENUMQUERYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl EnumQueryOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Ok(Self::builder().build())
-+
+    }
-+
+}
 impl EnumQueryOutput {
     /// Creates a new builder-style object to manufacture [`EnumQueryOutput`](crate::operation::enum_query::EnumQueryOutput).
     pub fn builder() -> crate::operation::enum_query::builders::EnumQueryOutputBuilder {
         crate::operation::enum_query::builders::EnumQueryOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`EnumQueryOutput`](crate::operation::enum_query::EnumQueryOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EnumQueryOutputBuilder {}
 impl EnumQueryOutputBuilder {
     /// Consumes the builder and constructs a [`EnumQueryOutput`](crate::operation::enum_query::EnumQueryOutput).
     pub fn build(self) -> crate::operation::enum_query::EnumQueryOutput {
         crate::operation::enum_query::EnumQueryOutput {}
-75
+    }
-76
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/escaped_string_values.rs

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

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

@@ -113,117 +234,299 @@

↥ Expand context

         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("EscapedStringValues")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(EscapedStringValuesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::escaped_string_values::EscapedStringValuesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::escaped_string_values::EscapedStringValuesError,
             >::new());
-136

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct EscapedStringValuesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for EscapedStringValuesResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::escaped_string_values::EscapedStringValuesError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "ValidationException" => crate::operation::escaped_string_values::EscapedStringValuesError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     tmp
                 }),
                 "ExtraError" => crate::operation::escaped_string_values::EscapedStringValuesError::ExtraError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ExtraError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ExtraError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::escaped_string_values::EscapedStringValuesError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_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, EscapedStringValues::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::escaped_string_values::EscapedStringValuesOutput::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))
-+
+        }
-248
+    }
-249
+}
 #[derive(Debug)]
 struct EscapedStringValuesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for EscapedStringValuesRequestSerializer {
     #[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::escaped_string_values::EscapedStringValuesInput>()
             .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::escaped_string_values::EscapedStringValuesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/escaped-string-values").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::escaped_string_values::EscapedStringValuesInput,
                 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, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::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, EscapedStringValues::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-270
+    }
-271
+}
 #[derive(Debug)]
 struct EscapedStringValuesEndpointParamsInterceptor;
-274
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EscapedStringValuesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "EscapedStringValuesEndpointParamsInterceptor"
-278
+    }
-279

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

@@ -291,356 +392,477 @@

↥ Expand context

                     .expect("static value validated to member"),
             ))
             .set_some_string(::std::option::Option::Some("test".to_owned()))
             .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(
                     "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",
                 ))
                 .unwrap(),
-367
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-371
         let op = crate::operation::escaped_string_values::EscapedStringValues::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");
-377
         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(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::escaped_string_values::EscapedStringValuesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.r#enum, expected_output.r#enum, "Unexpected value for `r#enum`");
         ::pretty_assertions::assert_eq!(parsed.some_string, expected_output.some_string, "Unexpected value for `some_string`");
-404
+    }
-405
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-418
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-422
         let op = crate::operation::escaped_string_values::EscapedStringValues::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");
-428
         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(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::escaped_string_values::EscapedStringValuesError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::escaped_string_values::EscapedStringValuesError::ExtraError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-456
+        }
-457
+    }

↧ Expand context

-458
+}
-459
 /// Error type for the `EscapedStringValuesError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum EscapedStringValuesError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationError(crate::types::error::ValidationError),
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::types::error::ExtraError),
     /// 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()`:
-471
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-473
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-EscapedStringValuesError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-476
+}
 impl EscapedStringValuesError {

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/escaped_string_values/_escaped_string_values_input.rs

@@ -3,3 +131,143 @@

↥ Expand context

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

     "aws.protocoltests.restjson.synthetic",
     "EscapedStringValuesInput",
 );
 static ESCAPEDSTRINGVALUESINPUT_MEMBER_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#EscapedStringValuesInput$enum",
         "aws.protocoltests.restjson.synthetic",
         "EscapedStringValuesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##enum",
     "enum",
 ,
 );
 static ESCAPEDSTRINGVALUESINPUT_MEMBER_SOME_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#EscapedStringValuesInput$someString",
         "aws.protocoltests.restjson.synthetic",
         "EscapedStringValuesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "some_string",
     "someString",
 ,
-45
+)
 .with_json_name("also\"has\"quotes");
 static ESCAPEDSTRINGVALUESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ESCAPEDSTRINGVALUESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ESCAPEDSTRINGVALUESINPUT_MEMBER_ENUM, &ESCAPEDSTRINGVALUESINPUT_MEMBER_SOME_STRING],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/escaped-string-values", None));
 impl EscapedStringValuesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ESCAPEDSTRINGVALUESINPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EscapedStringValuesInput {
     #[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.r#enum {
             ser.write_string(&ESCAPEDSTRINGVALUESINPUT_MEMBER_ENUM, val.as_str())?;
-65
+        }
         if let Some(ref val) = self.some_string {
             ser.write_string(&ESCAPEDSTRINGVALUESINPUT_MEMBER_SOME_STRING, val)?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl EscapedStringValuesInput {
     /// 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(&ESCAPEDSTRINGVALUESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ESCAPEDSTRINGVALUESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.r#enum = Some(crate::types::EnumWithEscapedChars::from(deser.read_string(member)?.as_str()));
-90
+                }
                 Some(1) => {
                     builder.some_string = Some(deser.read_string(member)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-101
+    }
-102
+}
 impl EscapedStringValuesInput {
     /// 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 EscapedStringValuesInput {
     /// Creates a new builder-style object to manufacture [`EscapedStringValuesInput`](crate::operation::escaped_string_values::EscapedStringValuesInput).
     pub fn builder() -> crate::operation::escaped_string_values::builders::EscapedStringValuesInputBuilder {
         crate::operation::escaped_string_values::builders::EscapedStringValuesInputBuilder::default()
-118
+    }
-119
+}
-120
 /// A builder for [`EscapedStringValuesInput`](crate::operation::escaped_string_values::EscapedStringValuesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EscapedStringValuesInputBuilder {
     pub(crate) r#enum: ::std::option::Option<crate::types::EnumWithEscapedChars>,
     pub(crate) some_string: ::std::option::Option<::std::string::String>,
-127
+}
 impl EscapedStringValuesInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#enum(mut self, input: crate::types::EnumWithEscapedChars) -> Self {
         self.r#enum = ::std::option::Option::Some(input);
         self
-133
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_enum(mut self, input: ::std::option::Option<crate::types::EnumWithEscapedChars>) -> Self {
         self.r#enum = input;
         self
-138
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_enum(&self) -> &::std::option::Option<crate::types::EnumWithEscapedChars> {
         &self.r#enum
-142
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/escaped_string_values/_escaped_string_values_output.rs

@@ -3,3 +129,140 @@

↥ Expand context

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

     "aws.protocoltests.restjson.synthetic",
     "EscapedStringValuesOutput",
 );
 static ESCAPEDSTRINGVALUESOUTPUT_MEMBER_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#EscapedStringValuesOutput$enum",
         "aws.protocoltests.restjson.synthetic",
         "EscapedStringValuesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##enum",
     "enum",
 ,
 );
 static ESCAPEDSTRINGVALUESOUTPUT_MEMBER_SOME_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#EscapedStringValuesOutput$someString",
         "aws.protocoltests.restjson.synthetic",
         "EscapedStringValuesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "some_string",
     "someString",
 ,
-45
+)
 .with_json_name("also\"has\"quotes");
 static ESCAPEDSTRINGVALUESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ESCAPEDSTRINGVALUESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ESCAPEDSTRINGVALUESOUTPUT_MEMBER_ENUM, &ESCAPEDSTRINGVALUESOUTPUT_MEMBER_SOME_STRING],
 );
 impl EscapedStringValuesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ESCAPEDSTRINGVALUESOUTPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for EscapedStringValuesOutput {
     #[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.r#enum {
             ser.write_string(&ESCAPEDSTRINGVALUESOUTPUT_MEMBER_ENUM, val.as_str())?;
-64
+        }
         if let Some(ref val) = self.some_string {
             ser.write_string(&ESCAPEDSTRINGVALUESOUTPUT_MEMBER_SOME_STRING, val)?;
-67
+        }
         Ok(())
-69
+    }
-70
+}
 impl EscapedStringValuesOutput {
     /// 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(&ESCAPEDSTRINGVALUESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ESCAPEDSTRINGVALUESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.r#enum = Some(crate::types::EnumWithEscapedChars::from(deser.read_string(member)?.as_str()));
-89
+                }
                 Some(1) => {
                     builder.some_string = Some(deser.read_string(member)?);
-92
+                }
                 _ => {}
-94
+            }
             Ok(())
         })?;
         Ok(builder.build())
-98
+    }
-99
+}
 impl EscapedStringValuesOutput {
     /// 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 EscapedStringValuesOutput {
     /// Creates a new builder-style object to manufacture [`EscapedStringValuesOutput`](crate::operation::escaped_string_values::EscapedStringValuesOutput).
     pub fn builder() -> crate::operation::escaped_string_values::builders::EscapedStringValuesOutputBuilder {
         crate::operation::escaped_string_values::builders::EscapedStringValuesOutputBuilder::default()
-115
+    }
-116
+}
-117
 /// A builder for [`EscapedStringValuesOutput`](crate::operation::escaped_string_values::EscapedStringValuesOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct EscapedStringValuesOutputBuilder {
     pub(crate) r#enum: ::std::option::Option<crate::types::EnumWithEscapedChars>,
     pub(crate) some_string: ::std::option::Option<::std::string::String>,
-124
+}
 impl EscapedStringValuesOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#enum(mut self, input: crate::types::EnumWithEscapedChars) -> Self {
         self.r#enum = ::std::option::Option::Some(input);
         self
-130
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_enum(mut self, input: ::std::option::Option<crate::types::EnumWithEscapedChars>) -> Self {
         self.r#enum = input;
         self
-135
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_enum(&self) -> &::std::option::Option<crate::types::EnumWithEscapedChars> {
         &self.r#enum
-139
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/operation/map_with_enum_key_op.rs

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

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

@@ -113,117 +233,299 @@

↥ Expand context

         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("MapWithEnumKeyOp")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(MapWithEnumKeyOpEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError,
             >::new());
-136

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct MapWithEnumKeyOpResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for MapWithEnumKeyOpResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "ValidationException" => crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     tmp
                 }),
                 "ExtraError" => crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::ExtraError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ExtraError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ExtraError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_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, MapWithEnumKeyOp::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::map_with_enum_key_op::MapWithEnumKeyOpOutput::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))
-+
+        }
-248
+    }
-249
+}
 #[derive(Debug)]
 struct MapWithEnumKeyOpRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for MapWithEnumKeyOpRequestSerializer {
     #[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::map_with_enum_key_op::MapWithEnumKeyOpInput>()
             .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::map_with_enum_key_op::MapWithEnumKeyOpInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/map-with-enum-key").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::map_with_enum_key_op::MapWithEnumKeyOpInput,
                 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, "application/json");
             builder
         };
         let body =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::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, MapWithEnumKeyOp::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-270
+    }
-271
+}
 #[derive(Debug)]
 struct MapWithEnumKeyOpEndpointParamsInterceptor;
-274
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for MapWithEnumKeyOpEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "MapWithEnumKeyOpEndpointParamsInterceptor"
-278
+    }
-279

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

@@ -292,358 +392,478 @@

↥ Expand context

                     "enumvalue".parse::<crate::types::StringEnum>().expect("static value validated to member"),
                     "something".to_owned(),
                 );
                 ret
             }))
             .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("{\"map\":{\"enumvalue\":\"something\"}}"))
                 .unwrap(),
-369
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-373
         let op = crate::operation::map_with_enum_key_op::MapWithEnumKeyOp::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");
-379
         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(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::map_with_enum_key_op::MapWithEnumKeyOpOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.map, expected_output.map, "Unexpected value for `map`");
-405
+    }
-406
     /// Upper case error modeled lower case
     /// Test ID: ServiceLevelErrorClient
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_client_response() {
         let expected_output = crate::types::error::ExtraError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("X-Amzn-Errortype", "ExtraError")
                 .status(500)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-419
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-423
         let op = crate::operation::map_with_enum_key_op::MapWithEnumKeyOp::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");
-429
         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(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::ExtraError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-457
+        }
-458
+    }

↧ Expand context

-459
+}
-460
 /// Error type for the `MapWithEnumKeyOpError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum MapWithEnumKeyOpError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationError(crate::types::error::ValidationError),
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::types::error::ExtraError),
     /// 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()`:
-472
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-474
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-MapWithEnumKeyOpError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-477
+}
 impl MapWithEnumKeyOpError {

Client Test

Files changed: