Client Test

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members/_operation_with_required_members_output.rs

@@ -65,65 +235,235 @@

-65
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_long(&self) -> i64 {
         self.required_long
-69
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_float(&self) -> f32 {
         self.required_float
-73
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_double(&self) -> f64 {
         self.required_double
-77
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_map(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
         &self.required_map
-81
+    }
-82
+}
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput",

     "aws.protocoltests.json10.synthetic",
     "OperationWithRequiredMembersOutput",
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredString",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "required_string",
     "requiredString",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredBoolean",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "required_boolean",
     "requiredBoolean",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredList",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "required_list",
     "requiredList",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredTimestamp",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "required_timestamp",
     "requiredTimestamp",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredBlob",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "required_blob",
     "requiredBlob",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredByte",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "required_byte",
     "requiredByte",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredShort",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "required_short",
     "requiredShort",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredInteger",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "required_integer",
     "requiredInteger",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredLong",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "required_long",
     "requiredLong",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredFloat",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "required_float",
     "requiredFloat",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredDouble",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "required_double",
     "requiredDouble",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersOutput$requiredMap",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "required_map",
     "requiredMap",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     OPERATIONWITHREQUIREDMEMBERSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_STRING,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_BOOLEAN,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_LIST,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_TIMESTAMP,

↧ Expand context

         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_BLOB,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_BYTE,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_SHORT,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_INTEGER,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_LONG,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_FLOAT,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_DOUBLE,
         &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_MAP,
     ],
 );
 impl OperationWithRequiredMembersOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OPERATIONWITHREQUIREDMEMBERSOUTPUT_SCHEMA;
-229
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithRequiredMembersOutput {
     #[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> {

@@ -278,278 +416,419 @@

↥ Expand context

             let val = &self.required_long;
             ser.write_long(&OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_LONG, *val)?;
-280
+        }
-281
+        {
             let val = &self.required_float;
             ser.write_float(&OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_FLOAT, *val)?;
-284
+        }
-285
+        {
             let val = &self.required_double;
             ser.write_double(&OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_DOUBLE, *val)?;
-288
+        }
-289
+        {
             let val = &self.required_map;
-291
             ser.write_map(
                 &OPERATIONWITHREQUIREDMEMBERSOUTPUT_MEMBER_REQUIRED_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)?;

-298
+                    }
                     Ok(())
                 },
             )?;
-302
+        }
         Ok(())
-304
+    }
-305
+}
 impl OperationWithRequiredMembersOutput {
     /// 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(&OPERATIONWITHREQUIREDMEMBERSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONWITHREQUIREDMEMBERSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.required_string = Some(deser.read_string(member)?);
-324
+                }
                 Some(1) => {
                     builder.required_boolean = Some(deser.read_boolean(member)?);
-327
+                }
                 Some(2) => {
                     builder.required_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.required_list = Some(deser.read_string_list(member)?);
-330
+                }
                 Some(3) => {
                     builder.required_timestamp = Some(deser.read_timestamp(member)?);
-333
+                }
                 Some(4) => {
                     builder.required_blob = Some(deser.read_blob(member)?);
-336
+                }
                 Some(5) => {
                     builder.required_byte = Some(deser.read_byte(member)?);
-339
+                }
                 Some(6) => {
                     builder.required_short = Some(deser.read_short(member)?);
-342
+                }
                 Some(7) => {
                     builder.required_integer = Some(deser.read_integer(member)?);
-345
+                }
                 Some(8) => {
                     builder.required_long = Some(deser.read_long(member)?);
-348
+                }
                 Some(9) => {
                     builder.required_float = Some(deser.read_float(member)?);
-351
+                }
                 Some(10) => {
                     builder.required_double = Some(deser.read_double(member)?);
-354
+                }
                 Some(11) => {
                     builder.required_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.required_map = Some(deser.read_string_string_map(member)?);
-357
+                }
                 _ => {}
-359
+            }
             Ok(())
         })?;
         builder.required_string = builder.required_string.or(Some(String::new()));
         builder.required_boolean = builder.required_boolean.or(Some(false));
         builder.required_list = builder.required_list.or(Some(Vec::new()));
         builder.required_timestamp = builder.required_timestamp.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         builder.required_blob = builder.required_blob.or(Some(::aws_smithy_types::Blob::new("")));
         builder.required_byte = builder.required_byte.or(Some(0i8));
         builder.required_short = builder.required_short.or(Some(0i16));
         builder.required_integer = builder.required_integer.or(Some(0i32));
         builder.required_long = builder.required_long.or(Some(0i64));
         builder.required_float = builder.required_float.or(Some(0.0f32));
         builder.required_double = builder.required_double.or(Some(0.0f64));
         builder.required_map = builder.required_map.or(Some(::std::collections::HashMap::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-377
+    }
-378
+}
 impl OperationWithRequiredMembersOutput {
     /// 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 OperationWithRequiredMembersOutput {
     /// Creates a new builder-style object to manufacture [`OperationWithRequiredMembersOutput`](crate::operation::operation_with_required_members::OperationWithRequiredMembersOutput).
     pub fn builder() -> crate::operation::operation_with_required_members::builders::OperationWithRequiredMembersOutputBuilder {
         crate::operation::operation_with_required_members::builders::OperationWithRequiredMembersOutputBuilder::default()
-394
+    }
-395
+}
-396
 /// A builder for [`OperationWithRequiredMembersOutput`](crate::operation::operation_with_required_members::OperationWithRequiredMembersOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithRequiredMembersOutputBuilder {
     pub(crate) required_string: ::std::option::Option<::std::string::String>,
     pub(crate) required_boolean: ::std::option::Option<bool>,
     pub(crate) required_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) required_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) required_byte: ::std::option::Option<i8>,
     pub(crate) required_short: ::std::option::Option<i16>,
     pub(crate) required_integer: ::std::option::Option<i32>,
     pub(crate) required_long: ::std::option::Option<i64>,
     pub(crate) required_float: ::std::option::Option<f32>,
     pub(crate) required_double: ::std::option::Option<f64>,
     pub(crate) required_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-413
+}
 impl OperationWithRequiredMembersOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn required_string(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.required_string = ::std::option::Option::Some(input.into());
         self

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members_with_defaults.rs

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

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

@@ -113,119 +242,238 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct OperationWithRequiredMembersWithDefaultsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationWithRequiredMembersWithDefaultsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_operation_with_required_members_with_defaults::de_operation_with_required_members_with_defaults_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::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_operation_with_required_members_with_defaults::de_operation_with_required_members_with_defaults_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, OperationWithRequiredMembersWithDefaults::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::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsOutput::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))
-+
+        }
-187
+    }
-188
+}
 #[derive(Debug)]
 struct OperationWithRequiredMembersWithDefaultsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OperationWithRequiredMembersWithDefaultsRequestSerializer {
     #[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::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsInput>()
             .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::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsInput,
                 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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.OperationWithRequiredMembersWithDefaults",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_operation_with_required_members_with_defaults::ser_operation_with_required_members_with_defaults_input(
                 &input,
             )?,
         );
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, OperationWithRequiredMembersWithDefaults::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-207
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-209
+    }
-210
+}
 #[derive(Debug)]
 struct OperationWithRequiredMembersWithDefaultsEndpointParamsInterceptor;
-213
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationWithRequiredMembersWithDefaultsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationWithRequiredMembersWithDefaultsEndpointParamsInterceptor"
-217
+    }
-218

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

@@ -275,271 +335,341 @@

↥ Expand context

                 .set_required_enum(::std::option::Option::Some(
                     "FOO".parse::<crate::types::RequiredEnum>().expect("static value validated to member"),
                 ))
                 .set_required_int_enum(::std::option::Option::Some(1))
                 .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-282
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-286
         let op = crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaults::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");
-292
         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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0("JsonRpc10"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.required_string,
             expected_output.required_string,
             "Unexpected value for `required_string`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.required_boolean,
             expected_output.required_boolean,
             "Unexpected value for `required_boolean`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.required_list,
             expected_output.required_list,
             "Unexpected value for `required_list`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.required_timestamp,
             expected_output.required_timestamp,
             "Unexpected value for `required_timestamp`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.required_blob,
             expected_output.required_blob,
             "Unexpected value for `required_blob`"
         );

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members_with_defaults/_operation_with_required_members_with_defaults_input.rs

@@ -1,1 +76,89 @@

↥ Expand context

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

     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-27
+    }
-28
+}
 impl OperationWithRequiredMembersWithDefaultsInput {
     /// 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(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-46
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-52
+    }
-53
+}
 impl OperationWithRequiredMembersWithDefaultsInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl OperationWithRequiredMembersWithDefaultsInput {
     /// Creates a new builder-style object to manufacture [`OperationWithRequiredMembersWithDefaultsInput`](crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsInput).
     pub fn builder() -> crate::operation::operation_with_required_members_with_defaults::builders::OperationWithRequiredMembersWithDefaultsInputBuilder
-70
+    {
         crate::operation::operation_with_required_members_with_defaults::builders::OperationWithRequiredMembersWithDefaultsInputBuilder::default()
-72
+    }
-73
+}
-74
 /// A builder for [`OperationWithRequiredMembersWithDefaultsInput`](crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members_with_defaults/_operation_with_required_members_with_defaults_output.rs

@@ -77,77 +268,268 @@

↥ Expand context

-77
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_double(&self) -> f64 {
         self.required_double
-81
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_map(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
         &self.required_map
-85
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_enum(&self) -> &crate::types::RequiredEnum {
         &self.required_enum
-89
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn required_int_enum(&self) -> i32 {
         self.required_int_enum
-93
+    }
-94
+}
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput",

     "aws.protocoltests.json10.synthetic",
     "OperationWithRequiredMembersWithDefaultsOutput",
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredString",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "required_string",
     "requiredString",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredBoolean",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "required_boolean",
     "requiredBoolean",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredList",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "required_list",
     "requiredList",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_TIMESTAMP: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredTimestamp",
             "aws.protocoltests.json10.synthetic",
             "OperationWithRequiredMembersWithDefaultsOutput",
         ),
         ::aws_smithy_schema::ShapeType::Timestamp,
         "required_timestamp",
         "requiredTimestamp",
 ,
     );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredBlob",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "required_blob",
     "requiredBlob",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredByte",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "required_byte",
     "requiredByte",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredShort",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "required_short",
     "requiredShort",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredInteger",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "required_integer",
     "requiredInteger",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredLong",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "required_long",
     "requiredLong",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredFloat",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "required_float",
     "requiredFloat",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredDouble",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "required_double",
     "requiredDouble",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredMap",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "required_map",
     "requiredMap",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredEnum",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "required_enum",
     "requiredEnum",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_INT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#OperationWithRequiredMembersWithDefaultsOutput$requiredIntEnum",
         "aws.protocoltests.json10.synthetic",
         "OperationWithRequiredMembersWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "required_int_enum",
     "requiredIntEnum",
 ,
 );
 static OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_STRING,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_BOOLEAN,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_LIST,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_TIMESTAMP,

↧ Expand context

         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_BLOB,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_BYTE,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_SHORT,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_INTEGER,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_LONG,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_FLOAT,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_DOUBLE,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_MAP,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_ENUM,
         &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_INT_ENUM,
     ],
 );
 impl OperationWithRequiredMembersWithDefaultsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_SCHEMA;
-264
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithRequiredMembersWithDefaultsOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

@@ -321,321 +463,454 @@

↥ Expand context

             let val = &self.required_double;
             ser.write_double(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_DOUBLE, *val)?;
-323
+        }
-324
+        {
             let val = &self.required_map;
-326
             ser.write_map(
                 &OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_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)?;
-333
+                    }
                     Ok(())
                 },
             )?;
-337
+        }
-338
+        {
             let val = &self.required_enum;
             ser.write_string(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_ENUM, val.as_str())?;

-341
+        }
-342
+        {
             let val = &self.required_int_enum;
             ser.write_integer(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_MEMBER_REQUIRED_INT_ENUM, *val)?;
-345
+        }
         Ok(())
-347
+    }
-348
+}
 impl OperationWithRequiredMembersWithDefaultsOutput {
     /// 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(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONWITHREQUIREDMEMBERSWITHDEFAULTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.required_string = Some(deser.read_string(member)?);
-367
+                }
                 Some(1) => {
                     builder.required_boolean = Some(deser.read_boolean(member)?);
-370
+                }
                 Some(2) => {
                     builder.required_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.required_list = Some(deser.read_string_list(member)?);
-373
+                }
                 Some(3) => {
                     builder.required_timestamp = Some(deser.read_timestamp(member)?);
-376
+                }
                 Some(4) => {
                     builder.required_blob = Some(deser.read_blob(member)?);
-379
+                }
                 Some(5) => {
                     builder.required_byte = Some(deser.read_byte(member)?);
-382
+                }
                 Some(6) => {
                     builder.required_short = Some(deser.read_short(member)?);
-385
+                }
                 Some(7) => {
                     builder.required_integer = Some(deser.read_integer(member)?);
-388
+                }
                 Some(8) => {
                     builder.required_long = Some(deser.read_long(member)?);
-391
+                }
                 Some(9) => {
                     builder.required_float = Some(deser.read_float(member)?);
-394
+                }
                 Some(10) => {
                     builder.required_double = Some(deser.read_double(member)?);
-397
+                }
                 Some(11) => {
                     builder.required_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.required_map = Some(deser.read_string_string_map(member)?);
-400
+                }
                 Some(12) => {
                     builder.required_enum = Some(crate::types::RequiredEnum::from(deser.read_string(member)?.as_str()));
-403
+                }
                 Some(13) => {
                     builder.required_int_enum = Some(deser.read_integer(member)?);
-406
+                }
                 _ => {}
-408
+            }
             Ok(())
         })?;
         Ok(builder.build())
-412
+    }
-413
+}
 impl OperationWithRequiredMembersWithDefaultsOutput {
     /// 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 OperationWithRequiredMembersWithDefaultsOutput {
     /// Creates a new builder-style object to manufacture [`OperationWithRequiredMembersWithDefaultsOutput`](crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsOutput).
     pub fn builder(
     ) -> crate::operation::operation_with_required_members_with_defaults::builders::OperationWithRequiredMembersWithDefaultsOutputBuilder {
         crate::operation::operation_with_required_members_with_defaults::builders::OperationWithRequiredMembersWithDefaultsOutputBuilder::default()
-430
+    }
-431
+}
-432
 /// A builder for [`OperationWithRequiredMembersWithDefaultsOutput`](crate::operation::operation_with_required_members_with_defaults::OperationWithRequiredMembersWithDefaultsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

↧ Expand context

 #[non_exhaustive]
 pub struct OperationWithRequiredMembersWithDefaultsOutputBuilder {
     pub(crate) required_string: ::std::option::Option<::std::string::String>,
     pub(crate) required_boolean: ::std::option::Option<bool>,
     pub(crate) required_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) required_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) required_byte: ::std::option::Option<i8>,
     pub(crate) required_short: ::std::option::Option<i16>,
     pub(crate) required_integer: ::std::option::Option<i32>,
     pub(crate) required_long: ::std::option::Option<i64>,
     pub(crate) required_float: ::std::option::Option<f32>,
     pub(crate) required_double: ::std::option::Option<f64>,
     pub(crate) required_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) required_enum: ::std::option::Option<crate::types::RequiredEnum>,
     pub(crate) required_int_enum: ::std::option::Option<i32>,
-451
+}
 impl OperationWithRequiredMembersWithDefaultsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.

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

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

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

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::put_with_content_encoding::PutWithContentEncodingError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::put_with_content_encoding::PutWithContentEncodingOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -113,117 +239,269 @@

↥ Expand context

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

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

↧ Expand context

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

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

@@ -43,43 +131,168 @@

↥ Expand context

     ::aws_smithy_schema::ShapeType::String,
     "data",
 ,
 );
 static PUTWITHCONTENTENCODINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTWITHCONTENTENCODINGINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING, &PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA],
 );
 impl PutWithContentEncodingInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTWITHCONTENTENCODINGINPUT_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutWithContentEncodingInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.encoding {

             ser.write_string(&PUTWITHCONTENTENCODINGINPUT_MEMBER_ENCODING, val)?;
-64
+        }
         if let Some(ref val) = self.data {
             ser.write_string(&PUTWITHCONTENTENCODINGINPUT_MEMBER_DATA, val)?;
-67
+        }
         Ok(())
-69
+    }
-70
+}
 impl PutWithContentEncodingInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.encoding = Some(deser.read_string(member)?);
-89
+                }
                 Some(1) => {
                     builder.data = Some(deser.read_string(member)?);
-92
+                }
                 _ => {}
-94
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-100
+    }
-101
+}
 impl PutWithContentEncodingInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("Content-Encoding") {
             builder.encoding = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTWITHCONTENTENCODINGINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => {
                     builder.data = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutWithContentEncodingInput {
     /// Creates a new builder-style object to manufacture [`PutWithContentEncodingInput`](crate::operation::put_with_content_encoding::PutWithContentEncodingInput).
     pub fn builder() -> crate::operation::put_with_content_encoding::builders::PutWithContentEncodingInputBuilder {
         crate::operation::put_with_content_encoding::builders::PutWithContentEncodingInputBuilder::default()
-143
+    }
-144
+}
-145
 /// A builder for [`PutWithContentEncodingInput`](crate::operation::put_with_content_encoding::PutWithContentEncodingInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/query_incompatible_operation.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `QueryIncompatibleOperation`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct QueryIncompatibleOperation;
 impl QueryIncompatibleOperation {
     /// Creates a new `QueryIncompatibleOperation`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::query_incompatible_operation::QueryIncompatibleOperationInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::query_incompatible_operation::QueryIncompatibleOperationOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::query_incompatible_operation::QueryIncompatibleOperationInput,
     ) -> ::std::result::Result<
         crate::operation::query_incompatible_operation::QueryIncompatibleOperationOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::query_incompatible_operation::QueryIncompatibleOperationError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::query_incompatible_operation::QueryIncompatibleOperationError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::query_incompatible_operation::QueryIncompatibleOperationOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -113,119 +236,241 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct QueryIncompatibleOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for QueryIncompatibleOperationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_query_incompatible_operation::de_query_incompatible_operation_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::query_incompatible_operation::QueryIncompatibleOperationError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_query_incompatible_operation::de_query_incompatible_operation_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, QueryIncompatibleOperation::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::query_incompatible_operation::QueryIncompatibleOperationOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct QueryIncompatibleOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for QueryIncompatibleOperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::query_incompatible_operation::QueryIncompatibleOperationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::query_incompatible_operation::QueryIncompatibleOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::query_incompatible_operation::QueryIncompatibleOperationInput,
                 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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.QueryIncompatibleOperation",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_query_incompatible_operation::ser_query_incompatible_operation_input(&input)?,
         );
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, QueryIncompatibleOperation::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-210
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct QueryIncompatibleOperationEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for QueryIncompatibleOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "QueryIncompatibleOperationEndpointParamsInterceptor"
-220
+    }
-221

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/query_incompatible_operation/_query_incompatible_operation_input.rs

@@ -1,1 +72,85 @@

↥ Expand context

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

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/query_incompatible_operation/_query_incompatible_operation_output.rs

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

↥ Expand context

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

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/simple_scalar_properties.rs

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

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

@@ -113,117 +239,239 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct SimpleScalarPropertiesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SimpleScalarPropertiesResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_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::simple_scalar_properties::SimpleScalarPropertiesError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_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, SimpleScalarProperties::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::simple_scalar_properties::SimpleScalarPropertiesOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct SimpleScalarPropertiesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SimpleScalarPropertiesRequestSerializer {
     #[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::simple_scalar_properties::SimpleScalarPropertiesInput>()
             .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::simple_scalar_properties::SimpleScalarPropertiesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
                 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/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.SimpleScalarProperties",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_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, SimpleScalarProperties::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct SimpleScalarPropertiesEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SimpleScalarPropertiesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SimpleScalarPropertiesEndpointParamsInterceptor"
-218
+    }
-219

↧ Expand context

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

@@ -388,388 +568,598 @@

↥ Expand context

                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"floatValue\": \"NaN\",\n    \"doubleValue\": \"NaN\"\n}",
                 ))
                 .unwrap(),
-399
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-403
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-409
         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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0("JsonRpc10"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
-446
+    }
-447
     /// Supports handling Infinity float values.
     /// Test ID: AwsJson10SupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_supports_infinity_float_inputs_response() {
         let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"floatValue\": \"Infinity\",\n    \"doubleValue\": \"Infinity\"\n}",
                 ))
                 .unwrap(),
-469
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-473
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-479
         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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0("JsonRpc10"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value
         );
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
-516
+    }
-517
     /// Supports handling -Infinity float values.
     /// Test ID: AwsJson10SupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_supports_negative_infinity_float_inputs_response() {
         let expected_output = crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput::builder()
             .set_float_value(::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .set_double_value(::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"floatValue\": \"-Infinity\",\n    \"doubleValue\": \"-Infinity\"\n}",
                 ))
                 .unwrap(),
-539
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-543
         let op = crate::operation::simple_scalar_properties::SimpleScalarProperties::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");
-549
         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_json_rpc::AwsJsonRpcProtocol::aws_json_1_0("JsonRpc10"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput>()
             .unwrap();
         assert!(
             parsed.float_value.float_equals(&expected_output.float_value),
             "Unexpected value for `float_value` {:?} vs. {:?}",
             expected_output.float_value,
             parsed.float_value

↧ Expand context

         );
         assert!(
             parsed.double_value.float_equals(&expected_output.double_value),
             "Unexpected value for `double_value` {:?} vs. {:?}",
             expected_output.double_value,
             parsed.double_value
         );
-586
+    }
-587
+}
-588
 /// Error type for the `SimpleScalarPropertiesError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum SimpleScalarPropertiesError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-596
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-598
+     \

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_input.rs

@@ -3,3 +133,144 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SimpleScalarPropertiesInput {
     #[allow(missing_docs)] // documentation missing in model
     pub float_value: ::std::option::Option<f32>,
     #[allow(missing_docs)] // documentation missing in model
     pub double_value: ::std::option::Option<f64>,
-10
+}
 impl SimpleScalarPropertiesInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn float_value(&self) -> ::std::option::Option<f32> {
         self.float_value
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn double_value(&self) -> ::std::option::Option<f64> {
         self.double_value
-19
+    }
-20
+}
 static SIMPLESCALARPROPERTIESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json10.synthetic#SimpleScalarPropertiesInput",

     "aws.protocoltests.json10.synthetic",
     "SimpleScalarPropertiesInput",
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#SimpleScalarPropertiesInput$floatValue",
         "aws.protocoltests.json10.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float_value",
     "floatValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#SimpleScalarPropertiesInput$doubleValue",
         "aws.protocoltests.json10.synthetic",
         "SimpleScalarPropertiesInput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double_value",
     "doubleValue",
 ,
 );
 static SIMPLESCALARPROPERTIESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SIMPLESCALARPROPERTIESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE,
         &SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE,
     ],
 );
 impl SimpleScalarPropertiesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SIMPLESCALARPROPERTIESINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SimpleScalarPropertiesInput {
     #[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.float_value {
             ser.write_float(&SIMPLESCALARPROPERTIESINPUT_MEMBER_FLOAT_VALUE, *val)?;
-66
+        }
         if let Some(ref val) = self.double_value {
             ser.write_double(&SIMPLESCALARPROPERTIESINPUT_MEMBER_DOUBLE_VALUE, *val)?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl SimpleScalarPropertiesInput {
     /// 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(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SIMPLESCALARPROPERTIESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.float_value = Some(deser.read_float(member)?);
-91
+                }
                 Some(1) => {
                     builder.double_value = Some(deser.read_double(member)?);
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-102
+    }
-103
+}
 impl SimpleScalarPropertiesInput {
     /// 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 SimpleScalarPropertiesInput {
     /// Creates a new builder-style object to manufacture [`SimpleScalarPropertiesInput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput).
     pub fn builder() -> crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesInputBuilder {
         crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesInputBuilder::default()
-119
+    }
-120
+}
-121
 /// A builder for [`SimpleScalarPropertiesInput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SimpleScalarPropertiesInputBuilder {
     pub(crate) float_value: ::std::option::Option<f32>,
     pub(crate) double_value: ::std::option::Option<f64>,
-128
+}
 impl SimpleScalarPropertiesInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn float_value(mut self, input: f32) -> Self {
         self.float_value = ::std::option::Option::Some(input);
         self
-134
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_float_value(mut self, input: ::std::option::Option<f32>) -> Self {
         self.float_value = input;
         self
-139
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_float_value(&self) -> &::std::option::Option<f32> {
         &self.float_value
-143
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_output.rs

@@ -3,3 +131,142 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SimpleScalarPropertiesOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub float_value: ::std::option::Option<f32>,
     #[allow(missing_docs)] // documentation missing in model
     pub double_value: ::std::option::Option<f64>,
-10
+}
 impl SimpleScalarPropertiesOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn float_value(&self) -> ::std::option::Option<f32> {
         self.float_value
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn double_value(&self) -> ::std::option::Option<f64> {
         self.double_value
-19
+    }
-20
+}
 static SIMPLESCALARPROPERTIESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json10.synthetic#SimpleScalarPropertiesOutput",

     "aws.protocoltests.json10.synthetic",
     "SimpleScalarPropertiesOutput",
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FLOAT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#SimpleScalarPropertiesOutput$floatValue",
         "aws.protocoltests.json10.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float_value",
     "floatValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_MEMBER_DOUBLE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10.synthetic#SimpleScalarPropertiesOutput$doubleValue",
         "aws.protocoltests.json10.synthetic",
         "SimpleScalarPropertiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double_value",
     "doubleValue",
 ,
 );
 static SIMPLESCALARPROPERTIESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SIMPLESCALARPROPERTIESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FLOAT_VALUE,
         &SIMPLESCALARPROPERTIESOUTPUT_MEMBER_DOUBLE_VALUE,
     ],
 );
 impl SimpleScalarPropertiesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SIMPLESCALARPROPERTIESOUTPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SimpleScalarPropertiesOutput {
     #[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.float_value {
             ser.write_float(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_FLOAT_VALUE, *val)?;
-66
+        }
         if let Some(ref val) = self.double_value {
             ser.write_double(&SIMPLESCALARPROPERTIESOUTPUT_MEMBER_DOUBLE_VALUE, *val)?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl SimpleScalarPropertiesOutput {
     /// 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(&SIMPLESCALARPROPERTIESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SIMPLESCALARPROPERTIESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.float_value = Some(deser.read_float(member)?);
-91
+                }
                 Some(1) => {
                     builder.double_value = Some(deser.read_double(member)?);
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         Ok(builder.build())
-100
+    }
-101
+}
 impl SimpleScalarPropertiesOutput {
     /// 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 SimpleScalarPropertiesOutput {
     /// Creates a new builder-style object to manufacture [`SimpleScalarPropertiesOutput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput).
     pub fn builder() -> crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder {
         crate::operation::simple_scalar_properties::builders::SimpleScalarPropertiesOutputBuilder::default()
-117
+    }
-118
+}
-119
 /// A builder for [`SimpleScalarPropertiesOutput`](crate::operation::simple_scalar_properties::SimpleScalarPropertiesOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct SimpleScalarPropertiesOutputBuilder {
     pub(crate) float_value: ::std::option::Option<f32>,
     pub(crate) double_value: ::std::option::Option<f64>,
-126
+}
 impl SimpleScalarPropertiesOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn float_value(mut self, input: f32) -> Self {
         self.float_value = ::std::option::Option::Some(input);
         self
-132
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_float_value(mut self, input: ::std::option::Option<f32>) -> Self {
         self.float_value = input;
         self
-137
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_float_value(&self) -> &::std::option::Option<f32> {
         &self.float_value
-141
+    }
     #[allow(missing_docs)] // documentation missing in model

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/protocol_serde.rs

@@ -1,1 +118,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
--
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
--
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
--
+}
--
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
-8
+}
--
 pub(crate) mod shape_content_type_parameters;
--
 pub(crate) mod shape_empty_input_and_empty_output;
--
 pub(crate) mod shape_endpoint_operation;
--
 pub(crate) mod shape_endpoint_with_host_label_operation;
--
 pub(crate) mod shape_greeting_with_errors;
--
 pub(crate) mod shape_host_with_path_operation;
--
 pub(crate) mod shape_json_unions;
--
 pub(crate) mod shape_no_input_and_no_output;
--
 pub(crate) mod shape_no_input_and_output;
--
 pub(crate) mod shape_operation_with_defaults;
--
 pub(crate) mod shape_operation_with_nested_structure;
--
 pub(crate) mod shape_operation_with_required_members;
--
 pub(crate) mod shape_operation_with_required_members_with_defaults;
--
 pub(crate) mod shape_put_with_content_encoding;
--
 pub(crate) mod shape_query_incompatible_operation;
--
 pub(crate) mod shape_simple_scalar_properties;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_complex_error;
--
 pub(crate) mod shape_content_type_parameters_input;
--
 pub(crate) mod shape_endpoint_with_host_label_operation_input;
--
 pub(crate) mod shape_foo_error;
--
 pub(crate) mod shape_greeting_with_errors_input;
--
 pub(crate) mod shape_invalid_greeting;
--
 pub(crate) mod shape_json_unions_input;
--
 pub(crate) mod shape_operation_with_defaults_input;
--
 pub(crate) mod shape_operation_with_nested_structure_input;
--
 pub(crate) mod shape_put_with_content_encoding_input;
--
 pub(crate) mod shape_simple_scalar_properties_input;
--
 pub(crate) mod shape_client_optional_defaults;
--
 pub(crate) mod shape_complex_nested_error_data;
--
 pub(crate) mod shape_defaults;
--
 pub(crate) mod shape_dialog;
--
 pub(crate) mod shape_dialog_list;
--
 pub(crate) mod shape_dialog_map;
--
 pub(crate) mod shape_my_union;
--
 pub(crate) mod shape_required_string_list;
--
 pub(crate) mod shape_required_string_map;
--
 pub(crate) mod shape_test_string_list;
--
 pub(crate) mod shape_test_string_map;
--
 pub(crate) mod shape_top_level;
--
 pub(crate) mod shape_farewell;
--
 pub(crate) mod shape_greeting_struct;
--
 pub(crate) mod shape_string_list;
--
 pub(crate) mod shape_string_map;

Client Test

Files changed:

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members/_operation_with_required_members_output.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members_with_defaults.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members_with_defaults/_operation_with_required_members_with_defaults_input.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_required_members_with_defaults/_operation_with_required_members_with_defaults_output.rs

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

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

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

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/query_incompatible_operation.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/query_incompatible_operation/_query_incompatible_operation_input.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/query_incompatible_operation/_query_incompatible_operation_output.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/simple_scalar_properties.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_input.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/simple_scalar_properties/_simple_scalar_properties_output.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/protocol_serde.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/protocol_serde/shape_client_optional_defaults.rs

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/protocol_serde/shape_complex_error.rs

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_client_optional_defaults(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::types::ClientOptionalDefaults,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.member {
         object.key("member").number(
             #[allow(clippy::useless_conversion)]
             ::aws_smithy_types::Number::NegInt((*var_1).into()),
         );
--
+    }
     Ok(())
--
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_complex_error_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::ComplexErrorBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::ComplexErrorBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "TopLevel" => {
                     builder = builder.set_top_level(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "Nested" => {
                     builder = builder.set_nested(crate::protocol_serde::shape_complex_nested_error_data::de_complex_nested_error_data(
                         tokens, _value,
                     )?);
--
+                }
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}