Client Test

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

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

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

@@ -104,108 +224,227 @@

↥ Expand context

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

                 crate::operation::json_lists::JsonListsError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct JsonListsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonListsResponseDeserializer {
     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;
-146
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_lists::de_json_lists_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::json_lists::JsonListsError::generic(generic)),
             ))
         } else {
             crate::protocol_serde::shape_json_lists::de_json_lists_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, JsonLists::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::json_lists::JsonListsOutput::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))
-+
+        }
-178
+    }
-179
+}
 #[derive(Debug)]
 struct JsonListsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonListsRequestSerializer {
     #[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::json_lists::JsonListsInput>().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::json_lists::JsonListsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/JsonLists").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_lists::JsonListsInput,
                 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_json_lists::ser_json_lists_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, JsonLists::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-198
+    }
-199
+}
 #[derive(Debug)]
 struct JsonListsEndpointParamsInterceptor;
-202
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonListsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonListsEndpointParamsInterceptor"
-206
+    }
-207

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

@@ -351,354 +411,424 @@

↥ Expand context

                     .build(),
                 crate::types::StructureListMember::builder()
                     .set_a(::std::option::Option::Some("3".to_owned()))
                     .set_b(::std::option::Option::Some("4".to_owned()))
                     .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    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\n        }\n    ]\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-369
         let op = crate::operation::json_lists::JsonLists::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");
-375
         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::json_lists::JsonListsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
         ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
         ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
         ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
         ::pretty_assertions::assert_eq!(

↧ Expand context

             parsed.timestamp_list,
             expected_output.timestamp_list,
             "Unexpected value for `timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.enum_list, expected_output.enum_list, "Unexpected value for `enum_list`");
         ::pretty_assertions::assert_eq!(
             parsed.int_enum_list,
             expected_output.int_enum_list,
             "Unexpected value for `int_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.nested_string_list,
             expected_output.nested_string_list,
             "Unexpected value for `nested_string_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.structure_list,
             expected_output.structure_list,
             "Unexpected value for `structure_list`"
         );

@@ -417,430 +477,500 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn rest_json_lists_empty_response() {
         let expected_output = crate::operation::json_lists::JsonListsOutput::builder()
             .set_string_list(::std::option::Option::Some(vec![]))
             .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    \"stringList\": []\n}"))
                 .unwrap(),
-441
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-445
         let op = crate::operation::json_lists::JsonLists::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");
-451
         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::json_lists::JsonListsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
         ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
         ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
         ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
         ::pretty_assertions::assert_eq!(

↧ Expand context

             parsed.timestamp_list,
             expected_output.timestamp_list,
             "Unexpected value for `timestamp_list`"
         );
         ::pretty_assertions::assert_eq!(parsed.enum_list, expected_output.enum_list, "Unexpected value for `enum_list`");
         ::pretty_assertions::assert_eq!(
             parsed.int_enum_list,
             expected_output.int_enum_list,
             "Unexpected value for `int_enum_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.nested_string_list,
             expected_output.nested_string_list,
             "Unexpected value for `nested_string_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.structure_list,
             expected_output.structure_list,
             "Unexpected value for `structure_list`"
         );

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

@@ -63,63 +221,222 @@

↥ Expand context

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.int_enum_list.is_none()`.
     pub fn int_enum_list(&self) -> &[i32] {
         self.int_enum_list.as_deref().unwrap_or_default()
-67
+    }
     /// A list of lists of strings.
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.nested_string_list.is_none()`.
     pub fn nested_string_list(&self) -> &[::std::vec::Vec<::std::string::String>] {
         self.nested_string_list.as_deref().unwrap_or_default()
-73
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.structure_list.is_none()`.
     pub fn structure_list(&self) -> &[crate::types::StructureListMember] {
         self.structure_list.as_deref().unwrap_or_default()
-79
+    }
-80
+}
 static JSONLISTSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonListsInput",

     "aws.protocoltests.restjson.synthetic",
     "JsonListsInput",
 );
 static JSONLISTSINPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$stringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_list",
     "stringList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$stringSet",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_set",
     "stringSet",
 ,
 );
 static JSONLISTSINPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$integerList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "integer_list",
     "integerList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$booleanList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "boolean_list",
     "booleanList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$timestampList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "timestamp_list",
     "timestampList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$enumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "enum_list",
     "enumList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$intEnumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "int_enum_list",
     "intEnumList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$nestedStringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "nested_string_list",
     "nestedStringList",
 ,
 );
 static JSONLISTSINPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsInput$structureList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "structure_list",
     "structureList",
 ,
-175
+)
 .with_json_name("myStructureList");
 static JSONLISTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONLISTSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONLISTSINPUT_MEMBER_STRING_LIST,
         &JSONLISTSINPUT_MEMBER_STRING_SET,
         &JSONLISTSINPUT_MEMBER_INTEGER_LIST,
         &JSONLISTSINPUT_MEMBER_BOOLEAN_LIST,
         &JSONLISTSINPUT_MEMBER_TIMESTAMP_LIST,
         &JSONLISTSINPUT_MEMBER_ENUM_LIST,
         &JSONLISTSINPUT_MEMBER_INT_ENUM_LIST,
         &JSONLISTSINPUT_MEMBER_NESTED_STRING_LIST,
         &JSONLISTSINPUT_MEMBER_STRUCTURE_LIST,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/JsonLists", None));
 impl JsonListsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONLISTSINPUT_SCHEMA;
-196
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonListsInput {
     #[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> {

↧ Expand context

         if let Some(ref val) = self.string_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-209
+                    }
                     Ok(())
                 },
             )?;
-213
+        }
         if let Some(ref val) = self.string_set {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_STRING_SET,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-220
+                    }
                     Ok(())
                 },

@@ -254,255 +475,447 @@

↥ Expand context

                 },
             )?;
-257
+        }
         if let Some(ref val) = self.enum_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-264
+                    }
                     Ok(())
                 },
             )?;
-268
+        }
         if let Some(ref val) = self.int_enum_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_INT_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_integer(&aws_smithy_schema::prelude::INTEGER, *item)?;

-275
+                    }
                     Ok(())
                 },
             )?;
-279
+        }
         if let Some(ref val) = self.nested_string_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_NESTED_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in item {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-294
+                    }
                     Ok(())
                 },
             )?;
-298
+        }
         if let Some(ref val) = self.structure_list {
             ser.write_list(
                 &JSONLISTSINPUT_MEMBER_STRUCTURE_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
-305
+                    }
                     Ok(())
                 },
             )?;
-309
+        }
         Ok(())
-311
+    }
-312
+}
 impl JsonListsInput {
     /// 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(&JSONLISTSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONLISTSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_list = Some(deser.read_string_list(member)?);
-331
+                }
                 Some(1) => {
                     builder.string_set = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_set = Some(deser.read_string_list(member)?);
-334
+                }
                 Some(2) => {
                     builder.integer_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.integer_list = Some(deser.read_integer_list(member)?);
-337
+                }
                 Some(3) => {
                     builder.boolean_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_boolean(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-347
+                }
                 Some(4) => {
                     builder.timestamp_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_timestamp(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_timestamp(member)?);
                             Ok(())
                         })?;
                         container
                     });
-357
+                }
                 Some(5) => {
                     builder.enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-367
+                }
                 Some(6) => {
                     builder.int_enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.int_enum_list = Some(deser.read_integer_list(member)?);
-370
+                }
                 Some(7) => {
                     builder.nested_string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 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
                     });
-387
+                }
                 Some(8) => {
                     builder.structure_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-397
+                }
                 _ => {}
-399
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-405
+    }
-406
+}
 impl JsonListsInput {
     /// 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 JsonListsInput {
     /// Creates a new builder-style object to manufacture [`JsonListsInput`](crate::operation::json_lists::JsonListsInput).
     pub fn builder() -> crate::operation::json_lists::builders::JsonListsInputBuilder {
         crate::operation::json_lists::builders::JsonListsInputBuilder::default()
-422
+    }
-423
+}
-424
 /// A builder for [`JsonListsInput`](crate::operation::json_lists::JsonListsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonListsInputBuilder {
     pub(crate) string_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) string_set: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) integer_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) boolean_list: ::std::option::Option<::std::vec::Vec<bool>>,
     pub(crate) timestamp_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
     pub(crate) enum_list: ::std::option::Option<::std::vec::Vec<crate::types::FooEnum>>,
     pub(crate) int_enum_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) nested_string_list: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
     pub(crate) structure_list: ::std::option::Option<::std::vec::Vec<crate::types::StructureListMember>>,
-438
+}
 impl JsonListsInputBuilder {
     /// Appends an item to `string_list`.
     ///
     /// To override the contents of this collection use [`set_string_list`](Self::set_string_list).
     ///
     pub fn string_list(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.string_list.unwrap_or_default();
         v.push(input.into());
         self.string_list = ::std::option::Option::Some(v);

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

@@ -63,63 +203,203 @@

↥ Expand context

     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.int_enum_list.is_none()`.
     pub fn int_enum_list(&self) -> &[i32] {
         self.int_enum_list.as_deref().unwrap_or_default()
-67
+    }
     /// A list of lists of strings.
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.nested_string_list.is_none()`.
     pub fn nested_string_list(&self) -> &[::std::vec::Vec<::std::string::String>] {
         self.nested_string_list.as_deref().unwrap_or_default()
-73
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.structure_list.is_none()`.
     pub fn structure_list(&self) -> &[crate::types::StructureListMember] {
         self.structure_list.as_deref().unwrap_or_default()
-79
+    }
-80
+}
 static JSONLISTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonListsOutput",

     "aws.protocoltests.restjson.synthetic",
     "JsonListsOutput",
 );
 static JSONLISTSOUTPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$stringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_list",
     "stringList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$stringSet",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "string_set",
     "stringSet",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$integerList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "integer_list",
     "integerList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$booleanList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "boolean_list",
     "booleanList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$timestampList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "timestamp_list",
     "timestampList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$enumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "enum_list",
     "enumList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$intEnumList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "int_enum_list",
     "intEnumList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$nestedStringList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "nested_string_list",
     "nestedStringList",
 ,
 );
 static JSONLISTSOUTPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonListsOutput$structureList",
         "aws.protocoltests.restjson.synthetic",
         "JsonListsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "structure_list",
     "structureList",
 ,
-175
+)
 .with_json_name("myStructureList");
 static JSONLISTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONLISTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONLISTSOUTPUT_MEMBER_STRING_LIST,
         &JSONLISTSOUTPUT_MEMBER_STRING_SET,
         &JSONLISTSOUTPUT_MEMBER_INTEGER_LIST,

↧ Expand context

         &JSONLISTSOUTPUT_MEMBER_BOOLEAN_LIST,
         &JSONLISTSOUTPUT_MEMBER_TIMESTAMP_LIST,
         &JSONLISTSOUTPUT_MEMBER_ENUM_LIST,
         &JSONLISTSOUTPUT_MEMBER_INT_ENUM_LIST,
         &JSONLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
         &JSONLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
     ],
 );
 impl JsonListsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONLISTSOUTPUT_SCHEMA;
-195
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonListsOutput {
     #[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.string_list {
             ser.write_list(

@@ -254,254 +473,444 @@

↥ Expand context

                 },
             )?;
-256
+        }
         if let Some(ref val) = self.enum_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_MEMBER_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-263
+                    }
                     Ok(())
                 },
             )?;
-267
+        }
         if let Some(ref val) = self.int_enum_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_MEMBER_INT_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_integer(&aws_smithy_schema::prelude::INTEGER, *item)?;

-274
+                    }
                     Ok(())
                 },
             )?;
-278
+        }
         if let Some(ref val) = self.nested_string_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in item {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-293
+                    }
                     Ok(())
                 },
             )?;
-297
+        }
         if let Some(ref val) = self.structure_list {
             ser.write_list(
                 &JSONLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
-304
+                    }
                     Ok(())
                 },
             )?;
-308
+        }
         Ok(())
-310
+    }
-311
+}
 impl JsonListsOutput {
     /// 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(&JSONLISTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONLISTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_list = Some(deser.read_string_list(member)?);
-330
+                }
                 Some(1) => {
                     builder.string_set = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.string_set = Some(deser.read_string_list(member)?);
-333
+                }
                 Some(2) => {
                     builder.integer_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.integer_list = Some(deser.read_integer_list(member)?);
-336
+                }
                 Some(3) => {
                     builder.boolean_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_boolean(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-346
+                }
                 Some(4) => {
                     builder.timestamp_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_timestamp(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_timestamp(member)?);
                             Ok(())
                         })?;
                         container
                     });
-356
+                }
                 Some(5) => {
                     builder.enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-366
+                }
                 Some(6) => {
                     builder.int_enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.int_enum_list = Some(deser.read_integer_list(member)?);
-369
+                }
                 Some(7) => {
                     builder.nested_string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push({
                                 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
                     });
-386
+                }
                 Some(8) => {
                     builder.structure_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::StructureListMember::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-396
+                }
                 _ => {}
-398
+            }
             Ok(())
         })?;
         Ok(builder.build())
-402
+    }
-403
+}
 impl JsonListsOutput {
     /// 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 JsonListsOutput {
     /// Creates a new builder-style object to manufacture [`JsonListsOutput`](crate::operation::json_lists::JsonListsOutput).
     pub fn builder() -> crate::operation::json_lists::builders::JsonListsOutputBuilder {
         crate::operation::json_lists::builders::JsonListsOutputBuilder::default()
-419
+    }
-420
+}
-421
 /// A builder for [`JsonListsOutput`](crate::operation::json_lists::JsonListsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonListsOutputBuilder {
     pub(crate) string_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) string_set: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) integer_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) boolean_list: ::std::option::Option<::std::vec::Vec<bool>>,
     pub(crate) timestamp_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
     pub(crate) enum_list: ::std::option::Option<::std::vec::Vec<crate::types::FooEnum>>,
     pub(crate) int_enum_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) nested_string_list: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
     pub(crate) structure_list: ::std::option::Option<::std::vec::Vec<crate::types::StructureListMember>>,
-435
+}
 impl JsonListsOutputBuilder {
     /// Appends an item to `string_list`.
     ///
     /// To override the contents of this collection use [`set_string_list`](Self::set_string_list).
     ///
     pub fn string_list(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.string_list.unwrap_or_default();
         v.push(input.into());
         self.string_list = ::std::option::Option::Some(v);

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

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

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

@@ -100,104 +220,223 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "JsonMaps",
             "Rest Json Protocol",
         ));
-108
         ::std::option::Option::Some(cfg.freeze())
-110
+    }
-111
     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("JsonMaps")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(JsonMapsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::json_maps::JsonMapsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::json_maps::JsonMapsError,
             >::new());
-126
         ::std::borrow::Cow::Owned(rcb)
-128
+    }
-129
+}
-130
 #[derive(Debug)]
 struct JsonMapsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonMapsResponseDeserializer {
     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;
-142
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_maps::de_json_maps_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::json_maps::JsonMapsError::generic(generic)),
             ))
         } else {
             crate::protocol_serde::shape_json_maps::de_json_maps_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, JsonMaps::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::json_maps::JsonMapsOutput::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))
-+
+        }
-174
+    }
-175
+}
 #[derive(Debug)]
 struct JsonMapsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonMapsRequestSerializer {
     #[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::json_maps::JsonMapsInput>().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::json_maps::JsonMapsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/JsonMaps").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_maps::JsonMapsInput,
                 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_json_maps::ser_json_maps_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, JsonMaps::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-194
+    }
-195
+}
 #[derive(Debug)]
 struct JsonMapsEndpointParamsInterceptor;
-198
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonMapsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonMapsEndpointParamsInterceptor"
-202
+    }
-203

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

@@ -377,380 +437,450 @@

↥ Expand context

                     crate::types::GreetingStruct::builder()
                         .set_hi(::std::option::Option::Some("bye".to_owned()))
                         .build(),
                 );
                 ret
             }))
             .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    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-395
         let op = crate::operation::json_maps::JsonMaps::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-401
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/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::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

@@ -454,467 +514,537 @@

↥ Expand context

                 ret
             }))
             .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    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}",
                 ))
                 .unwrap(),
-478
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-482
         let op = crate::operation::json_maps::JsonMaps::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");
-488
         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::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

@@ -527,550 +587,620 @@

↥ Expand context

                 ret
             }))
             .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    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}",
                 ))
                 .unwrap(),
-561
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-565
         let op = crate::operation::json_maps::JsonMaps::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");
-571
         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::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

@@ -602,635 +662,705 @@

↥ Expand context

                 ret
             }))
             .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    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}",
                 ))
                 .unwrap(),
-646
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-650
         let op = crate::operation::json_maps::JsonMaps::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");
-656
         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::json_maps::JsonMapsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.dense_struct_map,
             expected_output.dense_struct_map,
             "Unexpected value for `dense_struct_map`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.dense_number_map,
             expected_output.dense_number_map,
             "Unexpected value for `dense_number_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_boolean_map,
             expected_output.dense_boolean_map,
             "Unexpected value for `dense_boolean_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_string_map,
             expected_output.dense_string_map,
             "Unexpected value for `dense_string_map`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.dense_set_map,
             expected_output.dense_set_map,
             "Unexpected value for `dense_set_map`"
         );

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

@@ -23,23 +136,137 @@

↥ Expand context

     pub fn dense_number_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
         self.dense_number_map.as_ref()
-25
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, bool>> {
         self.dense_boolean_map.as_ref()
-29
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_string_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.dense_string_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         self.dense_set_map.as_ref()
-39
+    }
-40
+}
 static JSONMAPSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonMapsInput",

     "aws.protocoltests.restjson.synthetic",
     "JsonMapsInput",
 );
 static JSONMAPSINPUT_MEMBER_DENSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseStructMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_struct_map",
     "denseStructMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseNumberMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_number_map",
     "denseNumberMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseBooleanMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_boolean_map",
     "denseBooleanMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseStringMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_string_map",
     "denseStringMap",
 ,
 );
 static JSONMAPSINPUT_MEMBER_DENSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsInput$denseSetMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_set_map",
     "denseSetMap",
 ,
 );
 static JSONMAPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONMAPSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONMAPSINPUT_MEMBER_DENSE_STRUCT_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_NUMBER_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_STRING_MAP,
         &JSONMAPSINPUT_MEMBER_DENSE_SET_MAP,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/JsonMaps", None));
 impl JsonMapsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONMAPSINPUT_SCHEMA;
-111
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonMapsInput {
     #[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> {

↧ Expand context

         if let Some(ref val) = self.dense_struct_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::GreetingStruct::SCHEMA, value)?;
-125
+                    }
                     Ok(())
                 },
             )?;
-129
+        }
         if let Some(ref val) = self.dense_number_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_NUMBER_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_integer(&::aws_smithy_schema::prelude::INTEGER, *value)?;
-137
+                    }

@@ -141,142 +299,305 @@

↥ Expand context

         if let Some(ref val) = self.dense_boolean_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_boolean(&::aws_smithy_schema::prelude::BOOLEAN, *value)?;
-149
+                    }
                     Ok(())
                 },
             )?;
-153
+        }
         if let Some(ref val) = self.dense_string_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_STRING_MAP,
                 &|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)?;
-161
+                    }

                     Ok(())
                 },
             )?;
-165
+        }
         if let Some(ref val) = self.dense_set_map {
             ser.write_map(
                 &JSONMAPSINPUT_MEMBER_DENSE_SET_MAP,
                 &|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(())
                             },
                         )?;
-182
+                    }
                     Ok(())
                 },
             )?;
-186
+        }
         Ok(())
-188
+    }
-189
+}
 impl JsonMapsInput {
     /// 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(&JSONMAPSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONMAPSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dense_struct_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-215
+                }
                 Some(1) => {
                     builder.dense_number_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_integer(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-225
+                }
                 Some(2) => {
                     builder.dense_boolean_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_boolean(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-235
+                }
                 Some(3) => {
                     builder.dense_string_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.dense_string_map = Some(deser.read_string_string_map(member)?);
-238
+                }
                 Some(4) => {
                     builder.dense_set_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(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
                     });
-255
+                }
                 _ => {}
-257
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-263
+    }
-264
+}
 impl JsonMapsInput {
     /// 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 JsonMapsInput {
     /// Creates a new builder-style object to manufacture [`JsonMapsInput`](crate::operation::json_maps::JsonMapsInput).
     pub fn builder() -> crate::operation::json_maps::builders::JsonMapsInputBuilder {
         crate::operation::json_maps::builders::JsonMapsInputBuilder::default()
-280
+    }
-281
+}
-282
 /// A builder for [`JsonMapsInput`](crate::operation::json_maps::JsonMapsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonMapsInputBuilder {
     pub(crate) dense_struct_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::GreetingStruct>>,
     pub(crate) dense_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
     pub(crate) dense_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, bool>>,
     pub(crate) dense_string_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) dense_set_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
-292
+}
 impl JsonMapsInputBuilder {
     /// Adds a key-value pair to `dense_struct_map`.
     ///
     /// To override the contents of this collection use [`set_dense_struct_map`](Self::set_dense_struct_map).
     ///
     pub fn dense_struct_map(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::GreetingStruct) -> Self {
         let mut hash_map = self.dense_struct_map.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.dense_struct_map = ::std::option::Option::Some(hash_map);
         self
-303
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_dense_struct_map(

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

@@ -23,23 +123,123 @@

↥ Expand context

     pub fn dense_number_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
         self.dense_number_map.as_ref()
-25
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_boolean_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, bool>> {
         self.dense_boolean_map.as_ref()
-29
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_string_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.dense_string_map.as_ref()
-33
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dense_set_map(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         self.dense_set_map.as_ref()
-39
+    }
-40
+}
 static JSONMAPSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#JsonMapsOutput",

     "aws.protocoltests.restjson.synthetic",
     "JsonMapsOutput",
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseStructMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_struct_map",
     "denseStructMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseNumberMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_number_map",
     "denseNumberMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseBooleanMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_boolean_map",
     "denseBooleanMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseStringMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_string_map",
     "denseStringMap",
 ,
 );
 static JSONMAPSOUTPUT_MEMBER_DENSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#JsonMapsOutput$denseSetMap",
         "aws.protocoltests.restjson.synthetic",
         "JsonMapsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dense_set_map",
     "denseSetMap",
 ,
 );
 static JSONMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     JSONMAPSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &JSONMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP,
         &JSONMAPSOUTPUT_MEMBER_DENSE_NUMBER_MAP,
         &JSONMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP,
         &JSONMAPSOUTPUT_MEMBER_DENSE_STRING_MAP,

↧ Expand context

         &JSONMAPSOUTPUT_MEMBER_DENSE_SET_MAP,
     ],
 );
 impl JsonMapsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &JSONMAPSOUTPUT_SCHEMA;
-110
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonMapsOutput {
     #[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.dense_struct_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::GreetingStruct::SCHEMA, value)?;

@@ -141,141 +297,302 @@

↥ Expand context

         if let Some(ref val) = self.dense_boolean_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_boolean(&::aws_smithy_schema::prelude::BOOLEAN, *value)?;
-148
+                    }
                     Ok(())
                 },
             )?;
-152
+        }
         if let Some(ref val) = self.dense_string_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_STRING_MAP,
                 &|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)?;
-160
+                    }

                     Ok(())
                 },
             )?;
-164
+        }
         if let Some(ref val) = self.dense_set_map {
             ser.write_map(
                 &JSONMAPSOUTPUT_MEMBER_DENSE_SET_MAP,
                 &|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(())
                             },
                         )?;
-181
+                    }
                     Ok(())
                 },
             )?;
-185
+        }
         Ok(())
-187
+    }
-188
+}
 impl JsonMapsOutput {
     /// 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(&JSONMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&JSONMAPSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dense_struct_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-214
+                }
                 Some(1) => {
                     builder.dense_number_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_integer(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_integer(member)?);
                             Ok(())
                         })?;
                         container
                     });
-224
+                }
                 Some(2) => {
                     builder.dense_boolean_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_boolean(member)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-234
+                }
                 Some(3) => {
                     builder.dense_string_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.dense_string_map = Some(deser.read_string_string_map(member)?);
-237
+                }
                 Some(4) => {
                     builder.dense_set_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(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
                     });
-254
+                }
                 _ => {}
-256
+            }
             Ok(())
         })?;
         Ok(builder.build())
-260
+    }
-261
+}
 impl JsonMapsOutput {
     /// 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 JsonMapsOutput {
     /// Creates a new builder-style object to manufacture [`JsonMapsOutput`](crate::operation::json_maps::JsonMapsOutput).
     pub fn builder() -> crate::operation::json_maps::builders::JsonMapsOutputBuilder {
         crate::operation::json_maps::builders::JsonMapsOutputBuilder::default()
-277
+    }
-278
+}
-279
 /// A builder for [`JsonMapsOutput`](crate::operation::json_maps::JsonMapsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonMapsOutputBuilder {
     pub(crate) dense_struct_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::GreetingStruct>>,
     pub(crate) dense_number_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
     pub(crate) dense_boolean_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, bool>>,
     pub(crate) dense_string_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) dense_set_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
-289
+}
 impl JsonMapsOutputBuilder {
     /// Adds a key-value pair to `dense_struct_map`.
     ///
     /// To override the contents of this collection use [`set_dense_struct_map`](Self::set_dense_struct_map).
     ///
     pub fn dense_struct_map(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::GreetingStruct) -> Self {
         let mut hash_map = self.dense_struct_map.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.dense_struct_map = ::std::option::Option::Some(hash_map);
         self
-300
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_dense_struct_map(

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

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

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

@@ -104,108 +226,233 @@

↥ Expand context

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

                 crate::operation::json_timestamps::JsonTimestampsError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct JsonTimestampsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonTimestampsResponseDeserializer {
     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;
-146
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_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::json_timestamps::JsonTimestampsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_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, JsonTimestamps::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::json_timestamps::JsonTimestampsOutput::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))
-+
+        }
-182
+    }
-183
+}
 #[derive(Debug)]
 struct JsonTimestampsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonTimestampsRequestSerializer {
     #[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::json_timestamps::JsonTimestampsInput>()
             .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::json_timestamps::JsonTimestampsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/JsonTimestamps").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_timestamps::JsonTimestampsInput,
                 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_json_timestamps::ser_json_timestamps_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, JsonTimestamps::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-204
+    }
-205
+}
 #[derive(Debug)]
 struct JsonTimestampsEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonTimestampsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonTimestampsEndpointParamsInterceptor"
-212
+    }
-213

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

@@ -495,502 +555,572 @@

↥ Expand context

         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"normal\": 1398796238\n}"))
                 .unwrap(),
-513
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-517
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-523
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-571
+    }
-572

@@ -563,580 +623,650 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .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    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}",
                 ))
                 .unwrap(),
-591
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-595
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-601
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-649
+    }
-650

@@ -631,658 +691,728 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .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    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}",
                 ))
                 .unwrap(),
-669
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-673
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-679
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-727
+    }
-728

@@ -697,734 +757,804 @@

↥ Expand context

         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"epochSeconds\": 1398796238\n}"))
                 .unwrap(),
-745
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-749
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-755
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-803
+    }
-804

@@ -763,810 +823,880 @@

↥ Expand context

         let expected_output = crate::operation::json_timestamps::JsonTimestampsOutput::builder()
             .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1398796238, 0_f64,
             )))
             .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    \"epochSecondsOnTarget\": 1398796238\n}"))
                 .unwrap(),
-821
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-825
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-831
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-879
+    }
-880

@@ -831,888 +891,958 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .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    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                 ))
                 .unwrap(),
-899
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-903
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-909
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-957
+    }
-958

@@ -899,966 +959,1036 @@

↥ Expand context

                 1398796238, 0_f64,
             )))
             .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    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                 ))
                 .unwrap(),
-977
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-981
         let op = crate::operation::json_timestamps::JsonTimestamps::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");
-987
         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::json_timestamps::JsonTimestampsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
         ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
         ::pretty_assertions::assert_eq!(
             parsed.date_time_on_target,
             expected_output.date_time_on_target,

↧ Expand context

             "Unexpected value for `date_time_on_target`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds,
             expected_output.epoch_seconds,
             "Unexpected value for `epoch_seconds`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.epoch_seconds_on_target,
             expected_output.epoch_seconds_on_target,
             "Unexpected value for `epoch_seconds_on_target`"
         );
         ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
         ::pretty_assertions::assert_eq!(
             parsed.http_date_on_target,
             expected_output.http_date_on_target,
             "Unexpected value for `http_date_on_target`"
         );
-1035
+    }
-1036
+}

Client Test

Files changed:

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

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

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

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

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

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

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