Client Test

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

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

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

@@ -110,114 +234,239 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "PostUnionWithJsonName",
             "Rest Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PostUnionWithJsonName")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PostUnionWithJsonNameEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::post_union_with_json_name::PostUnionWithJsonNameError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::post_union_with_json_name::PostUnionWithJsonNameError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct PostUnionWithJsonNameResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PostUnionWithJsonNameResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::post_union_with_json_name::PostUnionWithJsonNameError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_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, PostUnionWithJsonName::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::post_union_with_json_name::PostUnionWithJsonNameOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct PostUnionWithJsonNameRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PostUnionWithJsonNameRequestSerializer {
     #[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::post_union_with_json_name::PostUnionWithJsonNameInput>()
             .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::post_union_with_json_name::PostUnionWithJsonNameInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/PostUnionWithJsonName").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::post_union_with_json_name::PostUnionWithJsonNameInput,
                 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_post_union_with_json_name::ser_post_union_with_json_name_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, PostUnionWithJsonName::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct PostUnionWithJsonNameEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PostUnionWithJsonNameEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PostUnionWithJsonNameEndpointParamsInterceptor"
-218
+    }
-219

↧ Expand context

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

@@ -354,359 +504,539 @@

↥ Expand context

             .set_value(::std::option::Option::Some(crate::types::UnionWithJsonName::Foo("hi".to_owned())))
             .build()
             .unwrap();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"value\": {\n        \"FOO\": \"hi\"\n    }\n}",
                 ))
                 .unwrap(),
-370
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-374
         let op = crate::operation::post_union_with_json_name::PostUnionWithJsonName::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");
-380
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.value, expected_output.value, "Unexpected value for `value`");
-406
+    }
-407
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse2
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_response2_response() {
         let expected_output = crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput::builder()
             .set_value(::std::option::Option::Some(crate::types::UnionWithJsonName::Baz("hi".to_owned())))
             .build()
             .unwrap();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"value\": {\n        \"_baz\": \"hi\"\n    }\n}",
                 ))
                 .unwrap(),
-425
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-429
         let op = crate::operation::post_union_with_json_name::PostUnionWithJsonName::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");
-435
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.value, expected_output.value, "Unexpected value for `value`");
-461
+    }
-462
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse3
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_response3_response() {
         let expected_output = crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput::builder()
             .set_value(::std::option::Option::Some(crate::types::UnionWithJsonName::Bar("hi".to_owned())))
             .build()
             .unwrap();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"value\": {\n        \"bar\": \"hi\"\n    }\n}",
                 ))
                 .unwrap(),
-480
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-484
         let op = crate::operation::post_union_with_json_name::PostUnionWithJsonName::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");
-490
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.value, expected_output.value, "Unexpected value for `value`");
-516
+    }
-517
+}
-518
 /// Error type for the `PostUnionWithJsonNameError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum PostUnionWithJsonNameError {
     /// 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()`:
-526
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-528
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-PostUnionWithJsonNameError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-531
+}
 impl PostUnionWithJsonNameError {
     /// Creates the `PostUnionWithJsonNameError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

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

@@ -4,4 +111,120 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PostUnionWithJsonNameInput {
     #[allow(missing_docs)] // documentation missing in model
     pub value: ::std::option::Option<crate::types::UnionWithJsonName>,
-8
+}
 impl PostUnionWithJsonNameInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn value(&self) -> ::std::option::Option<&crate::types::UnionWithJsonName> {
         self.value.as_ref()
-13
+    }
-14
+}
 static POSTUNIONWITHJSONNAMEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#PostUnionWithJsonNameInput",
     "aws.protocoltests.restjson.synthetic",
     "PostUnionWithJsonNameInput",
 );
 static POSTUNIONWITHJSONNAMEINPUT_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#PostUnionWithJsonNameInput$value",
         "aws.protocoltests.restjson.synthetic",

         "PostUnionWithJsonNameInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "value",
 ,
 );
 static POSTUNIONWITHJSONNAMEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     POSTUNIONWITHJSONNAMEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&POSTUNIONWITHJSONNAMEINPUT_MEMBER_VALUE],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/PostUnionWithJsonName", None));
 impl PostUnionWithJsonNameInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POSTUNIONWITHJSONNAMEINPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PostUnionWithJsonNameInput {
     #[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.value {
             ser.write_null(&POSTUNIONWITHJSONNAMEINPUT_MEMBER_VALUE)?;
             ser.write_struct(&POSTUNIONWITHJSONNAMEINPUT_MEMBER_VALUE, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl PostUnionWithJsonNameInput {
     /// 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(&POSTUNIONWITHJSONNAMEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&POSTUNIONWITHJSONNAMEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.value = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.value = Some(crate::types::UnionWithJsonName::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-78
+    }
-79
+}
 impl PostUnionWithJsonNameInput {
     /// 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 PostUnionWithJsonNameInput {
     /// Creates a new builder-style object to manufacture [`PostUnionWithJsonNameInput`](crate::operation::post_union_with_json_name::PostUnionWithJsonNameInput).
     pub fn builder() -> crate::operation::post_union_with_json_name::builders::PostUnionWithJsonNameInputBuilder {
         crate::operation::post_union_with_json_name::builders::PostUnionWithJsonNameInputBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`PostUnionWithJsonNameInput`](crate::operation::post_union_with_json_name::PostUnionWithJsonNameInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PostUnionWithJsonNameInputBuilder {
     pub(crate) value: ::std::option::Option<crate::types::UnionWithJsonName>,
-103
+}
 impl PostUnionWithJsonNameInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn value(mut self, input: crate::types::UnionWithJsonName) -> Self {
         self.value = ::std::option::Option::Some(input);
         self
-109
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_value(mut self, input: ::std::option::Option<crate::types::UnionWithJsonName>) -> Self {
         self.value = input;
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_value(&self) -> &::std::option::Option<crate::types::UnionWithJsonName> {
         &self.value
-118
+    }
     /// Consumes the builder and constructs a [`PostUnionWithJsonNameInput`](crate::operation::post_union_with_json_name::PostUnionWithJsonNameInput).
     pub fn build(

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

@@ -17,17 +112,120 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic",
     "PostUnionWithJsonNameOutput",
 );
 static POSTUNIONWITHJSONNAMEOUTPUT_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#PostUnionWithJsonNameOutput$value",
         "aws.protocoltests.restjson.synthetic",
         "PostUnionWithJsonNameOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "value",
 ,
 );
 static POSTUNIONWITHJSONNAMEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     POSTUNIONWITHJSONNAMEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&POSTUNIONWITHJSONNAMEOUTPUT_MEMBER_VALUE],
 );
 impl PostUnionWithJsonNameOutput {
     /// The schema for this shape.

     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POSTUNIONWITHJSONNAMEOUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PostUnionWithJsonNameOutput {
     #[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> {
-45
+        {
             let val = &self.value;
             ser.write_null(&POSTUNIONWITHJSONNAMEOUTPUT_MEMBER_VALUE)?;
             ser.write_struct(&POSTUNIONWITHJSONNAMEOUTPUT_MEMBER_VALUE, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl PostUnionWithJsonNameOutput {
     /// 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(&POSTUNIONWITHJSONNAMEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&POSTUNIONWITHJSONNAMEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.value = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.value = Some(crate::types::UnionWithJsonName::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-78
+    }
-79
+}
 impl PostUnionWithJsonNameOutput {
     /// 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 PostUnionWithJsonNameOutput {
     /// Creates a new builder-style object to manufacture [`PostUnionWithJsonNameOutput`](crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput).
     pub fn builder() -> crate::operation::post_union_with_json_name::builders::PostUnionWithJsonNameOutputBuilder {
         crate::operation::post_union_with_json_name::builders::PostUnionWithJsonNameOutputBuilder::default()
-95
+    }
-96
+}
-97
 /// A builder for [`PostUnionWithJsonNameOutput`](crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PostUnionWithJsonNameOutputBuilder {
     pub(crate) value: ::std::option::Option<crate::types::UnionWithJsonName>,
-103
+}
 impl PostUnionWithJsonNameOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn value(mut self, input: crate::types::UnionWithJsonName) -> Self {
         self.value = ::std::option::Option::Some(input);
         self
-110
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_value(mut self, input: ::std::option::Option<crate::types::UnionWithJsonName>) -> Self {
         self.value = input;
         self
-115
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_value(&self) -> &::std::option::Option<crate::types::UnionWithJsonName> {
         &self.value
-119
+    }
     /// Consumes the builder and constructs a [`PostUnionWithJsonNameOutput`](crate::operation::post_union_with_json_name::PostUnionWithJsonNameOutput).

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

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

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

@@ -110,114 +235,269 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "PutWithContentEncoding",
             "Rest Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("PutWithContentEncoding")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutWithContentEncodingEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_with_content_encoding::PutWithContentEncodingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::put_with_content_encoding::PutWithContentEncodingError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct PutWithContentEncodingResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutWithContentEncodingResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::put_with_content_encoding::PutWithContentEncodingError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_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, PutWithContentEncoding::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::put_with_content_encoding::PutWithContentEncodingOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct PutWithContentEncodingRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutWithContentEncodingRequestSerializer {
     #[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::put_with_content_encoding::PutWithContentEncodingInput>()
             .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::put_with_content_encoding::PutWithContentEncodingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/requestcompression/putcontentwithencoding").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_with_content_encoding::PutWithContentEncodingInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, PutWithContentEncoding::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/requestcompression/putcontentwithencoding".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.encoding {
                     request.headers_mut().insert("Content-Encoding", val.to_string());
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-230
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, PutWithContentEncoding::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-239
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-240
+    }
-241
+}
 #[derive(Debug)]
 struct PutWithContentEncodingEndpointParamsInterceptor;
-244
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutWithContentEncodingEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutWithContentEncodingEndpointParamsInterceptor"
-248
+    }
-249

↧ Expand context

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

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

@@ -21,21 +131,173 @@

↥ Expand context

 static PUTWITHCONTENTENCODINGINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#PutWithContentEncodingInput",
     "aws.protocoltests.restjson.synthetic",
     "PutWithContentEncodingInput",
 );
 static PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#PutWithContentEncodingInput$encoding",
         "aws.protocoltests.restjson.synthetic",
         "PutWithContentEncodingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "encoding",
 ,
-35
+)
 .with_http_header("Content-Encoding");
 static PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#PutWithContentEncodingInput$data",
         "aws.protocoltests.restjson.synthetic",

         "PutWithContentEncodingInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "data",
 ,
 );
 static PUTWITHCONTENTENCODINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTWITHCONTENTENCODINGINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING, &PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/requestcompression/putcontentwithencoding",
     None,
 ));
 impl PutWithContentEncodingInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTWITHCONTENTENCODINGINPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutWithContentEncodingInput {
     #[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.encoding {
             ser.write_string(&PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING, val)?;
-69
+        }
         if let Some(ref val) = self.data {
             ser.write_string(&PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA, val)?;
-72
+        }
         Ok(())
-74
+    }
-75
+}
 impl PutWithContentEncodingInput {
     /// 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(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.encoding = Some(deser.read_string(member)?);
-94
+                }
                 Some(1) => {
                     builder.data = Some(deser.read_string(member)?);
-97
+                }
                 _ => {}
-99
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-105
+    }
-106
+}
 impl PutWithContentEncodingInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("Content-Encoding") {
             builder.encoding = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.data = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutWithContentEncodingInput {
     /// Creates a new builder-style object to manufacture [`PutWithContentEncodingInput`](crate::operation::put_with_content_encoding::PutWithContentEncodingInput).
     pub fn builder() -> crate::operation::put_with_content_encoding::builders::PutWithContentEncodingInputBuilder {
         crate::operation::put_with_content_encoding::builders::PutWithContentEncodingInputBuilder::default()
-148
+    }
-149
+}
-150
 /// A builder for [`PutWithContentEncodingInput`](crate::operation::put_with_content_encoding::PutWithContentEncodingInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutWithContentEncodingInputBuilder {
     pub(crate) encoding: ::std::option::Option<::std::string::String>,
     pub(crate) data: ::std::option::Option<::std::string::String>,
-157
+}
 impl PutWithContentEncodingInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn encoding(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.encoding = ::std::option::Option::Some(input.into());
         self
-163
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_encoding(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.encoding = input;
         self
-168
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_encoding(&self) -> &::std::option::Option<::std::string::String> {
         &self.encoding
-172
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/put_with_content_encoding/_put_with_content_encoding_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 PutWithContentEncodingOutput {}
 static PUTWITHCONTENTENCODINGOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#PutWithContentEncodingOutput",
     "aws.protocoltests.restjson.synthetic",
     "PutWithContentEncodingOutput",
 );
 static PUTWITHCONTENTENCODINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTWITHCONTENTENCODINGOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl PutWithContentEncodingOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTWITHCONTENTENCODINGOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutWithContentEncodingOutput {

     #[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 PutWithContentEncodingOutput {
     /// 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(&PUTWITHCONTENTENCODINGOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTWITHCONTENTENCODINGOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl PutWithContentEncodingOutput {
     /// 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 PutWithContentEncodingOutput {
     /// Creates a new builder-style object to manufacture [`PutWithContentEncodingOutput`](crate::operation::put_with_content_encoding::PutWithContentEncodingOutput).
     pub fn builder() -> crate::operation::put_with_content_encoding::builders::PutWithContentEncodingOutputBuilder {
         crate::operation::put_with_content_encoding::builders::PutWithContentEncodingOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`PutWithContentEncodingOutput`](crate::operation::put_with_content_encoding::PutWithContentEncodingOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

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

@@ -118,124 +249,279 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "QueryIdempotencyTokenAutoFill",
             "Rest Json Protocol",
         ));
-128
         ::std::option::Option::Some(cfg.freeze())
-130
+    }
-131
     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("QueryIdempotencyTokenAutoFill")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(QueryIdempotencyTokenAutoFillEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillError,
             >::new());
-146
         ::std::borrow::Cow::Owned(rcb)
-148
+    }
-149
+}
-150
 #[derive(Debug)]
 struct QueryIdempotencyTokenAutoFillResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryIdempotencyTokenAutoFillResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_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, QueryIdempotencyTokenAutoFill::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::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillOutput::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))
-+
+        }
-198
+    }
-199
+}
 #[derive(Debug)]
 struct QueryIdempotencyTokenAutoFillRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for QueryIdempotencyTokenAutoFillRequestSerializer {
     #[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::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput>()
             .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::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/QueryIdempotencyTokenAutoFill").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_1) = &_input.token {
--
+                    {
                         query.push_kv("token", &::aws_smithy_http::query::fmt_string(inner_1));
--
+                    }
         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, QueryIdempotencyTokenAutoFill::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/QueryIdempotencyTokenAutoFill".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.token {
                     query_params.push(("token".to_string(), val.to_string()));
-224
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput,
                 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)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").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");
-240
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-241
         ::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, QueryIdempotencyTokenAutoFill::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-250
+    }
-251
+}
 #[derive(Debug)]
 struct QueryIdempotencyTokenAutoFillEndpointParamsInterceptor;
-254
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryIdempotencyTokenAutoFillEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryIdempotencyTokenAutoFillEndpointParamsInterceptor"
-258
+    }
-259

↧ 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::<QueryIdempotencyTokenAutoFillInput>()
             .ok_or("failed to downcast to QueryIdempotencyTokenAutoFillInput")?;
-274
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

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

@@ -5,5 +109,121 @@

↥ Expand context

 pub struct QueryIdempotencyTokenAutoFillInput {
     #[allow(missing_docs)] // documentation missing in model
     pub token: ::std::option::Option<::std::string::String>,
-8
+}
 impl QueryIdempotencyTokenAutoFillInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn token(&self) -> ::std::option::Option<&str> {
         self.token.as_deref()
-13
+    }
-14
+}
 static QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#QueryIdempotencyTokenAutoFillInput",
     "aws.protocoltests.restjson.synthetic",
     "QueryIdempotencyTokenAutoFillInput",
 );
 static QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_MEMBER_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#QueryIdempotencyTokenAutoFillInput$token",
         "aws.protocoltests.restjson.synthetic",
         "QueryIdempotencyTokenAutoFillInput",

     ),
     ::aws_smithy_schema::ShapeType::String,
     "token",
 ,
-29
+)
 .with_http_query("token");
 static QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_MEMBER_TOKEN],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/QueryIdempotencyTokenAutoFill", None));
 impl QueryIdempotencyTokenAutoFillInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryIdempotencyTokenAutoFillInput {
     #[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.token {
             ser.write_string(&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_MEMBER_TOKEN, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl QueryIdempotencyTokenAutoFillInput {
     /// 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(&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYIDEMPOTENCYTOKENAUTOFILLINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.token = Some(deser.read_string(member)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl QueryIdempotencyTokenAutoFillInput {
     /// 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 QueryIdempotencyTokenAutoFillInput {
     /// Creates a new builder-style object to manufacture [`QueryIdempotencyTokenAutoFillInput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput).
     pub fn builder() -> crate::operation::query_idempotency_token_auto_fill::builders::QueryIdempotencyTokenAutoFillInputBuilder {
         crate::operation::query_idempotency_token_auto_fill::builders::QueryIdempotencyTokenAutoFillInputBuilder::default()
-96
+    }
-97
+}
-98
 /// A builder for [`QueryIdempotencyTokenAutoFillInput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct QueryIdempotencyTokenAutoFillInputBuilder {
     pub(crate) token: ::std::option::Option<::std::string::String>,
-104
+}
 impl QueryIdempotencyTokenAutoFillInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.token = ::std::option::Option::Some(input.into());
         self
-110
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.token = input;
         self
-115
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_token(&self) -> &::std::option::Option<::std::string::String> {
         &self.token
-119
+    }
     /// Consumes the builder and constructs a [`QueryIdempotencyTokenAutoFillInput`](crate::operation::query_idempotency_token_auto_fill::QueryIdempotencyTokenAutoFillInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/query_idempotency_token_auto_fill/_query_idempotency_token_auto_fill_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 QueryIdempotencyTokenAutoFillOutput {}
 static QUERYIDEMPOTENCYTOKENAUTOFILLOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#QueryIdempotencyTokenAutoFillOutput",
     "aws.protocoltests.restjson.synthetic",
     "QueryIdempotencyTokenAutoFillOutput",
 );
 static QUERYIDEMPOTENCYTOKENAUTOFILLOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYIDEMPOTENCYTOKENAUTOFILLOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
 impl QueryIdempotencyTokenAutoFillOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYIDEMPOTENCYTOKENAUTOFILLOUTPUT_SCHEMA;
-19
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryIdempotencyTokenAutoFillOutput {

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

↧ Expand context

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

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

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

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

@@ -110,116 +253,281 @@

↥ Expand context

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

                 crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct QueryParamsAsStringListMapResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryParamsAsStringListMapResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_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, QueryParamsAsStringListMap::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::query_params_as_string_list_map::QueryParamsAsStringListMapOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct QueryParamsAsStringListMapRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for QueryParamsAsStringListMapRequestSerializer {
     #[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::query_params_as_string_list_map::QueryParamsAsStringListMapInput>()
             .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::query_params_as_string_list_map::QueryParamsAsStringListMapInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/StringListMap").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let protected_params = ["corge"];
                 if let ::std::option::Option::Some(inner_1) = &_input.foo {
--
+                    {
                         for (k, v) in inner_1 {
                             for inner_2 in v {
                                 if !protected_params.contains(&k.as_str()) {
                                     query.push_kv(&::aws_smithy_http::query::fmt_string(k), &::aws_smithy_http::query::fmt_string(inner_2));
--
+                                }
--
+                            }
         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, QueryParamsAsStringListMap::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/StringListMap".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.qux {
                     query_params.push(("corge".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref map) = input.foo {
                     for (k, v) in map {
                         if matches!(k.as_str(), "corge") {
                             continue;
-+
+                        }
                         for item in v {
                             query_params.push((k.clone(), item.clone()));
-224
+                        }
-225
+                    }
-226
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.qux {
--
+                    {
                         query.push_kv("corge", &::aws_smithy_http::query::fmt_string(inner_3));
--
+                    }
                 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("&"));
-240
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapInput,
                 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)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
                 request.set_uri(uri.as_str()).expect("valid URI");
-242
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-243
         ::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, QueryParamsAsStringListMap::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-252
+    }
-253
+}
 #[derive(Debug)]
 struct QueryParamsAsStringListMapEndpointParamsInterceptor;
-256
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryParamsAsStringListMapEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryParamsAsStringListMapEndpointParamsInterceptor"
-260
+    }
-261

↧ 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::<QueryParamsAsStringListMapInput>()
             .ok_or("failed to downcast to QueryParamsAsStringListMapInput")?;
-276
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

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

@@ -22,22 +151,176 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic#QueryParamsAsStringListMapInput",
     "aws.protocoltests.restjson.synthetic",
     "QueryParamsAsStringListMapInput",
 );
 static QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_QUX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#QueryParamsAsStringListMapInput$qux",
         "aws.protocoltests.restjson.synthetic",
         "QueryParamsAsStringListMapInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "qux",
 ,
-35
+)
 .with_http_query("corge");
 static QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#QueryParamsAsStringListMapInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "QueryParamsAsStringListMapInput",

     ),
     ::aws_smithy_schema::ShapeType::Map,
     "foo",
 ,
-46
+)
 .with_http_query_params();
 static QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_QUX, &QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_FOO],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/StringListMap", None));
 impl QueryParamsAsStringListMapInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryParamsAsStringListMapInput {
     #[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.qux {
             ser.write_string(&QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_QUX, val)?;
-66
+        }
         if let Some(ref val) = self.foo {
             ser.write_map(
                 &QUERYPARAMSASSTRINGLISTMAPINPUT_MEMBER_FOO,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
-+
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-83
+                    }
                     Ok(())
                 },
             )?;
-87
+        }
         Ok(())
-89
+    }
-90
+}
 impl QueryParamsAsStringListMapInput {
     /// 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(&QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYPARAMSASSTRINGLISTMAPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.qux = Some(deser.read_string(member)?);
-109
+                }
                 Some(1) => {
                     builder.foo = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-126
+                }
                 _ => {}
-128
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-134
+    }
-135
+}
 impl QueryParamsAsStringListMapInput {
     /// 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 QueryParamsAsStringListMapInput {
     /// Creates a new builder-style object to manufacture [`QueryParamsAsStringListMapInput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapInput).
     pub fn builder() -> crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapInputBuilder {
         crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapInputBuilder::default()
-151
+    }
-152
+}
-153
 /// A builder for [`QueryParamsAsStringListMapInput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct QueryParamsAsStringListMapInputBuilder {
     pub(crate) qux: ::std::option::Option<::std::string::String>,
     pub(crate) foo: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
-160
+}
 impl QueryParamsAsStringListMapInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn qux(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.qux = ::std::option::Option::Some(input.into());
         self
-166
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_qux(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.qux = input;
         self
-171
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_qux(&self) -> &::std::option::Option<::std::string::String> {
         &self.qux
-175
+    }
     /// Adds a key-value pair to `foo`.

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/query_params_as_string_list_map/_query_params_as_string_list_map_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 QueryParamsAsStringListMapOutput {}
 static QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#QueryParamsAsStringListMapOutput",
     "aws.protocoltests.restjson.synthetic",
     "QueryParamsAsStringListMapOutput",
 );
 static QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl QueryParamsAsStringListMapOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryParamsAsStringListMapOutput {

     #[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 QueryParamsAsStringListMapOutput {
     /// 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(&QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYPARAMSASSTRINGLISTMAPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl QueryParamsAsStringListMapOutput {
     /// 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 QueryParamsAsStringListMapOutput {
     /// Creates a new builder-style object to manufacture [`QueryParamsAsStringListMapOutput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapOutput).
     pub fn builder() -> crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapOutputBuilder {
         crate::operation::query_params_as_string_list_map::builders::QueryParamsAsStringListMapOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`QueryParamsAsStringListMapOutput`](crate::operation::query_params_as_string_list_map::QueryParamsAsStringListMapOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

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

@@ -110,114 +251,277 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "QueryPrecedence",
             "Rest Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("QueryPrecedence")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(QueryPrecedenceEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::query_precedence::QueryPrecedenceError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::query_precedence::QueryPrecedenceError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct QueryPrecedenceResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryPrecedenceResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::query_precedence::QueryPrecedenceError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_query_precedence::de_query_precedence_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, QueryPrecedence::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::query_precedence::QueryPrecedenceOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct QueryPrecedenceRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for QueryPrecedenceRequestSerializer {
     #[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::query_precedence::QueryPrecedenceInput>()
             .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::query_precedence::QueryPrecedenceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/Precedence").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::query_precedence::QueryPrecedenceInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let protected_params = ["bar"];
                 if let ::std::option::Option::Some(inner_1) = &_input.baz {
--
+                    {
                         for (k, v) in inner_1 {
                             if !protected_params.contains(&k.as_str()) {
                                 query.push_kv(&::aws_smithy_http::query::fmt_string(k), &::aws_smithy_http::query::fmt_string(v));
--
+                            }
         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, QueryPrecedence::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/Precedence".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.foo {
                     query_params.push(("bar".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref map) = input.baz {
                     for (k, v) in map {
                         if matches!(k.as_str(), "bar") {
                             continue;
-219
+                        }
                         query_params.push((k.clone(), v.clone()));
-221
+                    }
-222
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.foo {
--
+                    {
                         query.push_kv("bar", &::aws_smithy_http::query::fmt_string(inner_2));
--
+                    }
                 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("&"));
-236
+                }
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-238
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::query_precedence::QueryPrecedenceInput,
                 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)?;
                 uri_query(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("");
-239
         ::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, QueryPrecedence::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-248
+    }
-249
+}
 #[derive(Debug)]
 struct QueryPrecedenceEndpointParamsInterceptor;
-252
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryPrecedenceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryPrecedenceEndpointParamsInterceptor"
-256
+    }
-257

↧ 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::<QueryPrecedenceInput>()
             .ok_or("failed to downcast to QueryPrecedenceInput")?;
-272
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

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

@@ -22,22 +151,153 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic#QueryPrecedenceInput",
     "aws.protocoltests.restjson.synthetic",
     "QueryPrecedenceInput",
 );
 static QUERYPRECEDENCEINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#QueryPrecedenceInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "QueryPrecedenceInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",
 ,
-35
+)
 .with_http_query("bar");
 static QUERYPRECEDENCEINPUT_MEMBER_BAZ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#QueryPrecedenceInput$baz",
         "aws.protocoltests.restjson.synthetic",
         "QueryPrecedenceInput",

     ),
     ::aws_smithy_schema::ShapeType::Map,
     "baz",
 ,
-46
+)
 .with_http_query_params();
 static QUERYPRECEDENCEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     QUERYPRECEDENCEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&QUERYPRECEDENCEINPUT_MEMBER_FOO, &QUERYPRECEDENCEINPUT_MEMBER_BAZ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/Precedence", None));
 impl QueryPrecedenceInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYPRECEDENCEINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryPrecedenceInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.foo {
             ser.write_string(&QUERYPRECEDENCEINPUT_MEMBER_FOO, val)?;
-66
+        }
         if let Some(ref val) = self.baz {
             ser.write_map(
                 &QUERYPRECEDENCEINPUT_MEMBER_BAZ,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-74
+                    }
                     Ok(())
                 },
             )?;
-78
+        }
         Ok(())
-80
+    }
-81
+}
 impl QueryPrecedenceInput {
     /// 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(&QUERYPRECEDENCEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYPRECEDENCEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-100
+                }
                 Some(1) => {
                     builder.baz = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.baz = Some(deser.read_string_string_map(member)?);
-103
+                }
                 _ => {}
-105
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-111
+    }
-112
+}
 impl QueryPrecedenceInput {
     /// 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 QueryPrecedenceInput {
     /// Creates a new builder-style object to manufacture [`QueryPrecedenceInput`](crate::operation::query_precedence::QueryPrecedenceInput).
     pub fn builder() -> crate::operation::query_precedence::builders::QueryPrecedenceInputBuilder {
         crate::operation::query_precedence::builders::QueryPrecedenceInputBuilder::default()
-128
+    }
-129
+}
-130
 /// A builder for [`QueryPrecedenceInput`](crate::operation::query_precedence::QueryPrecedenceInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct QueryPrecedenceInputBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
     pub(crate) baz: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-137
+}
 impl QueryPrecedenceInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-143
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-148
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-152
+    }
     /// Adds a key-value pair to `baz`.

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/query_precedence/_query_precedence_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 QueryPrecedenceOutput {}
 static QUERYPRECEDENCEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#QueryPrecedenceOutput",
     "aws.protocoltests.restjson.synthetic",
     "QueryPrecedenceOutput",
 );
 static QUERYPRECEDENCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(QUERYPRECEDENCEOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl QueryPrecedenceOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYPRECEDENCEOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for QueryPrecedenceOutput {

     #[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 QueryPrecedenceOutput {
     /// 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(&QUERYPRECEDENCEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&QUERYPRECEDENCEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl QueryPrecedenceOutput {
     /// 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 QueryPrecedenceOutput {
     /// Creates a new builder-style object to manufacture [`QueryPrecedenceOutput`](crate::operation::query_precedence::QueryPrecedenceOutput).
     pub fn builder() -> crate::operation::query_precedence::builders::QueryPrecedenceOutputBuilder {
         crate::operation::query_precedence::builders::QueryPrecedenceOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`QueryPrecedenceOutput`](crate::operation::query_precedence::QueryPrecedenceOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

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

@@ -110,114 +232,239 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "RecursiveShapes",
             "Rest Json Protocol",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("RecursiveShapes")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(RecursiveShapesEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::recursive_shapes::RecursiveShapesError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::recursive_shapes::RecursiveShapesError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct RecursiveShapesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RecursiveShapesResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::recursive_shapes::RecursiveShapesError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_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, RecursiveShapes::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::recursive_shapes::RecursiveShapesOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct RecursiveShapesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RecursiveShapesRequestSerializer {
     #[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::recursive_shapes::RecursiveShapesInput>()
             .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::recursive_shapes::RecursiveShapesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/RecursiveShapes").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::recursive_shapes::RecursiveShapesInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_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, RecursiveShapes::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct RecursiveShapesEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RecursiveShapesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RecursiveShapesEndpointParamsInterceptor"
-218
+    }
-219

↧ Expand context

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

@@ -315,322 +375,392 @@

↥ Expand context

                                     .build(),
                             ))
                             .build(),
                     )))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/json")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"nested\": {\n        \"foo\": \"Foo1\",\n        \"nested\": {\n            \"bar\": \"Bar1\",\n            \"recursiveMember\": {\n                \"foo\": \"Foo2\",\n                \"nested\": {\n                    \"bar\": \"Bar2\"\n                }\n            }\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-337
         let op = crate::operation::recursive_shapes::RecursiveShapes::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");
-343
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::recursive_shapes::RecursiveShapesOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-369
+    }
-370
+}
-371
 /// Error type for the `RecursiveShapesError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum RecursiveShapesError {
     /// 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()`:
-379
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-381
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-RecursiveShapesError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-384
+}
 impl RecursiveShapesError {
     /// Creates the `RecursiveShapesError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

Client Test

Files changed: