Client Test

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/float16.rs

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

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

@@ -97,101 +159,164 @@

↥ Expand context

                 .expect("required fields set"),
         ));
-103
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("Float16", "RpcV2Protocol"));
-105
         ::std::option::Option::Some(cfg.freeze())
-107
+    }
-108
     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("Float16")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(Float16EndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::float16::Float16Error,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::float16::Float16Error,
             >::new());
-123
         ::std::borrow::Cow::Owned(rcb)
-125
+    }
-126
+}
-127
 #[derive(Debug)]
 struct Float16ResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for Float16ResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-141
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_float16::de_float16_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_float16::de_float16_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-148
+    }
-149
+}
 #[derive(Debug)]
 struct Float16RequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for Float16RequestSerializer {
     #[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::float16::Float16Input>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {

@@ -242,247 +500,525 @@

↥ Expand context

             .set_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/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("oWV2YWx1Zfl8AA=="))
                 .unwrap(),
-258
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-262
         let op = crate::operation::float16::Float16::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");
-268
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::float16::Float16Output>()
             .unwrap();
         assert!(
             parsed.value.float_equals(&expected_output.value),
             "Unexpected value for `value` {:?} vs. {:?}",
             expected_output.value,
             parsed.value
         );
-293
+    }
-294
     /// Ensures that clients can correctly parse float16 -Inf.
     /// Test ID: RpcV2CborFloat16NegInf
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_float16_neg_inf_response() {
         let expected_output = crate::operation::float16::Float16Output::builder()
             .set_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/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("oWV2YWx1Zfn8AA=="))
                 .unwrap(),
-312
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-316
         let op = crate::operation::float16::Float16::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");
-322
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::float16::Float16Output>()
             .unwrap();
         assert!(
             parsed.value.float_equals(&expected_output.value),
             "Unexpected value for `value` {:?} vs. {:?}",
             expected_output.value,
             parsed.value
         );
-347
+    }
-348
     /// Ensures that clients can correctly parse float16 NaN with high LSB.
     /// Test ID: RpcV2CborFloat16LSBNaN
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_float16_lsb_na_n_response() {
         let expected_output = crate::operation::float16::Float16Output::builder()
             .set_value(::std::option::Option::Some(
                 <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/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("oWV2YWx1Zfl8AQ=="))
                 .unwrap(),
-366
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-370
         let op = crate::operation::float16::Float16::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-376
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::float16::Float16Output>()
             .unwrap();
         assert!(
             parsed.value.float_equals(&expected_output.value),
             "Unexpected value for `value` {:?} vs. {:?}",
             expected_output.value,
             parsed.value
         );
-401
+    }
-402
     /// Ensures that clients can correctly parse float16 NaN with high MSB.
     /// Test ID: RpcV2CborFloat16MSBNaN
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_float16_msb_na_n_response() {
         let expected_output = crate::operation::float16::Float16Output::builder()
             .set_value(::std::option::Option::Some(
                 <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/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("oWV2YWx1Zfl+AA=="))
                 .unwrap(),
-420
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-424
         let op = crate::operation::float16::Float16::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");
-430
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::float16::Float16Output>()
             .unwrap();
         assert!(
             parsed.value.float_equals(&expected_output.value),
             "Unexpected value for `value` {:?} vs. {:?}",
             expected_output.value,
             parsed.value
         );
-455
+    }
-456
     /// Ensures that clients can correctly parse a subnormal float16.
     /// Test ID: RpcV2CborFloat16Subnormal
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_float16_subnormal_response() {
         let expected_output = crate::operation::float16::Float16Output::builder()
             .set_value(::std::option::Option::Some(4.76837158203125E-6_f64))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("oWV2YWx1ZfkAUA=="))
                 .unwrap(),
-472
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-476
         let op = crate::operation::float16::Float16::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");
-482
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::float16::Float16Output>()
             .unwrap();
         assert!(
             parsed.value.float_equals(&expected_output.value),
             "Unexpected value for `value` {:?} vs. {:?}",
             expected_output.value,
             parsed.value

↧ Expand context

         );
-507
+    }
-508
+}
-509
 /// Error type for the `Float16Error` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum Float16Error {
     /// 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()`:
-517
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-519
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-Float16Error) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-522
+}
 impl Float16Error {
     /// Creates the `Float16Error::Unhandled` variant from any error type.
     pub fn unhandled(

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/float16/_float16_input.rs

@@ -1,1 +67,80 @@

↥ 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 Float16Input {}
 static FLOAT16INPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#Float16Input",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "Float16Input",
 );
 static FLOAT16INPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(FLOAT16INPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl Float16Input {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLOAT16INPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Float16Input {

     #[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 Float16Input {
     /// 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(&FLOAT16INPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLOAT16INPUT_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 Float16Input {
     /// 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 Float16Input {
     /// Creates a new builder-style object to manufacture [`Float16Input`](crate::operation::float16::Float16Input).
     pub fn builder() -> crate::operation::float16::builders::Float16InputBuilder {
         crate::operation::float16::builders::Float16InputBuilder::default()
-68
+    }
-69
+}
-70
 /// A builder for [`Float16Input`](crate::operation::float16::Float16Input).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct Float16InputBuilder {}
 impl Float16InputBuilder {
     /// Consumes the builder and constructs a [`Float16Input`](crate::operation::float16::Float16Input).
     pub fn build(self) -> ::std::result::Result<crate::operation::float16::Float16Input, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::float16::Float16Input {})
-79
+    }
-80
+}

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/float16/_float16_output.rs

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

↥ Expand context

         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "Float16Output",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "value",
 ,
 );
 static FLOAT16OUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FLOAT16OUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FLOAT16OUTPUT_MEMBER_VALUE],
 );
 impl Float16Output {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FLOAT16OUTPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Float16Output {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.value {
             ser.write_double(&FLOAT16OUTPUT_MEMBER_VALUE, *val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl Float16Output {
     /// 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(&FLOAT16OUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FLOAT16OUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.value = Some(deser.read_double(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         Ok(builder.build())
-75
+    }
-76
+}
 impl Float16Output {
     /// 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 Float16Output {
     /// Creates a new builder-style object to manufacture [`Float16Output`](crate::operation::float16::Float16Output).
     pub fn builder() -> crate::operation::float16::builders::Float16OutputBuilder {
         crate::operation::float16::builders::Float16OutputBuilder::default()
-92
+    }
-93
+}
-94
 /// A builder for [`Float16Output`](crate::operation::float16::Float16Output).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct Float16OutputBuilder {
     pub(crate) value: ::std::option::Option<f64>,
-100
+}
 impl Float16OutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn value(mut self, input: f64) -> Self {
         self.value = ::std::option::Option::Some(input);
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_value(mut self, input: ::std::option::Option<f64>) -> Self {
         self.value = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_value(&self) -> &::std::option::Option<f64> {
         &self.value
-115
+    }
     /// Consumes the builder and constructs a [`Float16Output`](crate::operation::float16::Float16Output).
     pub fn build(self) -> crate::operation::float16::Float16Output {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/fractional_seconds.rs

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

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

@@ -104,108 +166,171 @@

↥ Expand context

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

                 crate::operation::fractional_seconds::FractionalSecondsError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct FractionalSecondsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for FractionalSecondsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-155
+    }
-156
+}
 #[derive(Debug)]
 struct FractionalSecondsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for FractionalSecondsRequestSerializer {
     #[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::fractional_seconds::FractionalSecondsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -250,255 +310,319 @@

↥ Expand context

             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 946845296, 0.123_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v2hkYXRldGltZcH7Qcw32zgPvnf/"))
                 .unwrap(),
-266
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-270
         let op = crate::operation::fractional_seconds::FractionalSeconds::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");
-276
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::fractional_seconds::FractionalSecondsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.datetime, expected_output.datetime, "Unexpected value for `datetime`");
-296
+    }
-297
+}
-298
 /// Error type for the `FractionalSecondsError` operation.

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/fractional_seconds/_fractional_seconds_input.rs

@@ -1,1 +69,82 @@

↥ 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 FractionalSecondsInput {}
 static FRACTIONALSECONDSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#FractionalSecondsInput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "FractionalSecondsInput",
 );
 static FRACTIONALSECONDSINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(FRACTIONALSECONDSINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl FractionalSecondsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FRACTIONALSECONDSINPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FractionalSecondsInput {

     #[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 FractionalSecondsInput {
     /// 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(&FRACTIONALSECONDSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FRACTIONALSECONDSINPUT_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 FractionalSecondsInput {
     /// 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 FractionalSecondsInput {
     /// Creates a new builder-style object to manufacture [`FractionalSecondsInput`](crate::operation::fractional_seconds::FractionalSecondsInput).
     pub fn builder() -> crate::operation::fractional_seconds::builders::FractionalSecondsInputBuilder {
         crate::operation::fractional_seconds::builders::FractionalSecondsInputBuilder::default()
-68
+    }
-69
+}
-70
 /// A builder for [`FractionalSecondsInput`](crate::operation::fractional_seconds::FractionalSecondsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FractionalSecondsInputBuilder {}
 impl FractionalSecondsInputBuilder {
     /// Consumes the builder and constructs a [`FractionalSecondsInput`](crate::operation::fractional_seconds::FractionalSecondsInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::fractional_seconds::FractionalSecondsInput, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::fractional_seconds::FractionalSecondsInput {})
-81
+    }
-82
+}

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/fractional_seconds/_fractional_seconds_output.rs

@@ -1,1 +106,118 @@

↥ 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 FractionalSecondsOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub datetime: ::std::option::Option<::aws_smithy_types::DateTime>,
-8
+}
 impl FractionalSecondsOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn datetime(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.datetime.as_ref()
-13
+    }
-14
+}
 static FRACTIONALSECONDSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#FractionalSecondsOutput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "FractionalSecondsOutput",

 );
 static FRACTIONALSECONDSOUTPUT_MEMBER_DATETIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#FractionalSecondsOutput$datetime",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "FractionalSecondsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "datetime",
 ,
 );
-+
+)
 .with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 static FRACTIONALSECONDSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     FRACTIONALSECONDSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&FRACTIONALSECONDSOUTPUT_MEMBER_DATETIME],
 );
 impl FractionalSecondsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FRACTIONALSECONDSOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FractionalSecondsOutput {
     #[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.datetime {
             ser.write_timestamp(&FRACTIONALSECONDSOUTPUT_MEMBER_DATETIME, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl FractionalSecondsOutput {
     /// 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(&FRACTIONALSECONDSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FRACTIONALSECONDSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.datetime = Some(deser.read_timestamp(member)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl FractionalSecondsOutput {
     /// 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 FractionalSecondsOutput {
     /// Creates a new builder-style object to manufacture [`FractionalSecondsOutput`](crate::operation::fractional_seconds::FractionalSecondsOutput).
     pub fn builder() -> crate::operation::fractional_seconds::builders::FractionalSecondsOutputBuilder {
         crate::operation::fractional_seconds::builders::FractionalSecondsOutputBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`FractionalSecondsOutput`](crate::operation::fractional_seconds::FractionalSecondsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FractionalSecondsOutputBuilder {
     pub(crate) datetime: ::std::option::Option<::aws_smithy_types::DateTime>,
-101
+}
 impl FractionalSecondsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn datetime(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.datetime = ::std::option::Option::Some(input);
         self
-107
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_datetime(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.datetime = input;
         self
-112
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_datetime(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         &self.datetime
-116
+    }
     /// Consumes the builder and constructs a [`FractionalSecondsOutput`](crate::operation::fractional_seconds::FractionalSecondsOutput).
     pub fn build(self) -> crate::operation::fractional_seconds::FractionalSecondsOutput {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/greeting_with_errors.rs

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

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

@@ -104,108 +166,171 @@

↥ Expand context

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

                 crate::operation::greeting_with_errors::GreetingWithErrorsError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct GreetingWithErrorsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GreetingWithErrorsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-155
+    }
-156
+}
 #[derive(Debug)]
 struct GreetingWithErrorsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GreetingWithErrorsRequestSerializer {
     #[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::greeting_with_errors::GreetingWithErrorsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -250,255 +409,426 @@

↥ Expand context

             .set_message(::std::option::Option::Some("Hi".to_owned()))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(400)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2ZfX3R5cGV4LnNtaXRoeS5wcm90b2NvbHRlc3RzLnJwY3YyQ2JvciNJbnZhbGlkR3JlZXRpbmdnTWVzc2FnZWJIaf8=",
                 ))
                 .unwrap(),
-266
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-270
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-276
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-298
+        }
-299
+    }
-300
     /// Parses a complex error with no message member
     /// Test ID: RpcV2CborComplexError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_complex_error_response() {
         let expected_output = crate::types::error::ComplexError::builder()
             .set_top_level(::std::option::Option::Some("Top level".to_owned()))
             .set_nested(::std::option::Option::Some(
                 crate::types::ComplexNestedErrorData::builder()
                     .set_foo(::std::option::Option::Some("bar".to_owned()))
                     .build(),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(400)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2ZfX3R5cGV4K3NtaXRoeS5wcm90b2NvbHRlc3RzLnJwY3YyQ2JvciNDb21wbGV4RXJyb3JoVG9wTGV2ZWxpVG9wIGxldmVsZk5lc3RlZL9jRm9vY2Jhcv//",
                 ))
                 .unwrap(),
-323
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-327
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-333
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.top_level, expected_output.top_level, "Unexpected value for `top_level`");
             ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);
-357
+        }
-358
+    }
     /// Test ID: RpcV2CborEmptyComplexError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rpc_v2_cbor_empty_complex_error_response() {
         let expected_output = crate::types::error::ComplexError::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(400)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "v2ZfX3R5cGV4K3NtaXRoeS5wcm90b2NvbHRlc3RzLnJwY3YyQ2JvciNDb21wbGV4RXJyb3L/",
                 ))
                 .unwrap(),
-373
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-377
         let op = crate::operation::greeting_with_errors::GreetingWithErrors::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");
-383
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed.expect_err("should be error response");
         let parsed: &crate::operation::greeting_with_errors::GreetingWithErrorsError =
             parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
         if let crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError(parsed) = parsed {
             ::pretty_assertions::assert_eq!(parsed.top_level, expected_output.top_level, "Unexpected value for `top_level`");
             ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
             ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
         } else {
             panic!("wrong variant: Got: {:?}. Expected: {:?}", parsed, expected_output);

↧ Expand context

-407
+        }
-408
+    }
-409
+}
-410
 /// Error type for the `GreetingWithErrorsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum GreetingWithErrorsError {
     /// This error is thrown when an invalid greeting value is provided.
     InvalidGreeting(crate::types::error::InvalidGreeting),
     /// This error is thrown when a request is invalid.
     ComplexError(crate::types::error::ComplexError),
     /// 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()`:
-422
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-424
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-GreetingWithErrorsError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/greeting_with_errors/_greeting_with_errors_input.rs

@@ -1,1 +70,83 @@

↥ 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 GreetingWithErrorsInput {}
 static GREETINGWITHERRORSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#GreetingWithErrorsInput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "GreetingWithErrorsInput",
 );
 static GREETINGWITHERRORSINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(GREETINGWITHERRORSINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl GreetingWithErrorsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GREETINGWITHERRORSINPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GreetingWithErrorsInput {

     #[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 GreetingWithErrorsInput {
     /// 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(&GREETINGWITHERRORSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GREETINGWITHERRORSINPUT_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 GreetingWithErrorsInput {
     /// 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 GreetingWithErrorsInput {
     /// Creates a new builder-style object to manufacture [`GreetingWithErrorsInput`](crate::operation::greeting_with_errors::GreetingWithErrorsInput).
     pub fn builder() -> crate::operation::greeting_with_errors::builders::GreetingWithErrorsInputBuilder {
         crate::operation::greeting_with_errors::builders::GreetingWithErrorsInputBuilder::default()
-68
+    }
-69
+}
-70
 /// A builder for [`GreetingWithErrorsInput`](crate::operation::greeting_with_errors::GreetingWithErrorsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GreetingWithErrorsInputBuilder {}
 impl GreetingWithErrorsInputBuilder {
     /// Consumes the builder and constructs a [`GreetingWithErrorsInput`](crate::operation::greeting_with_errors::GreetingWithErrorsInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::greeting_with_errors::GreetingWithErrorsInput, ::aws_smithy_types::error::operation::BuildError>
-80
+    {
         ::std::result::Result::Ok(crate::operation::greeting_with_errors::GreetingWithErrorsInput {})
-82
+    }
-83
+}

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/greeting_with_errors/_greeting_with_errors_output.rs

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

↥ Expand context

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

↧ Expand context

 pub struct GreetingWithErrorsOutputBuilder {
     pub(crate) greeting: ::std::option::Option<::std::string::String>,
-100
+}
 impl GreetingWithErrorsOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn greeting(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.greeting = ::std::option::Option::Some(input.into());
         self
-106
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_greeting(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.greeting = input;
         self
-111
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_greeting(&self) -> &::std::option::Option<::std::string::String> {
         &self.greeting
-115
+    }
     /// Consumes the builder and constructs a [`GreetingWithErrorsOutput`](crate::operation::greeting_with_errors::GreetingWithErrorsOutput).
     pub fn build(self) -> crate::operation::greeting_with_errors::GreetingWithErrorsOutput {

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/no_input_output.rs

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

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

@@ -104,108 +166,171 @@

↥ Expand context

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

                 crate::operation::no_input_output::NoInputOutputError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct NoInputOutputResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for NoInputOutputResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_no_input_output::de_no_input_output_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_no_input_output::de_no_input_output_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-155
+    }
-156
+}
 #[derive(Debug)]
 struct NoInputOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for NoInputOutputRequestSerializer {
     #[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::no_input_output::NoInputOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -274,279 +415,432 @@

↥ Expand context

     /// Test ID: no_output
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn no_output_response() {
         let expected_output = crate::operation::no_input_output::NoInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-290
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-294
         let op = crate::operation::no_input_output::NoInputOutput::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");
-300
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_output::NoInputOutputOutput>()
             .unwrap();
-319
+    }
-320
     /// Clients should accept a CBOR empty struct if there is no output.
     /// Test ID: NoOutputClientAllowsEmptyCbor
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn no_output_client_allows_empty_cbor_response() {
         let expected_output = crate::operation::no_input_output::NoInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v/8="))
                 .unwrap(),
-334
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-338
         let op = crate::operation::no_input_output::NoInputOutput::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");
-344
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_output::NoInputOutputOutput>()
             .unwrap();
-363
+    }
-364
     /// Clients should accept an empty body if there is no output and
     /// should not raise an error if the `Content-Type` header is set.
     /// Test ID: NoOutputClientAllowsEmptyBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn no_output_client_allows_empty_body_response() {
         let expected_output = crate::operation::no_input_output::NoInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-379
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-383
         let op = crate::operation::no_input_output::NoInputOutput::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");
-389
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_output::NoInputOutputOutput>()
             .unwrap();
-408
+    }
-409
+}
-410
 /// Error type for the `NoInputOutputError` operation.
 #[non_exhaustive]

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/no_input_output/_no_input_output_input.rs

@@ -1,1 +69,82 @@

↥ 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 NoInputOutputInput {}
 static NOINPUTOUTPUTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#NoInputOutputInput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "NoInputOutputInput",
 );
 static NOINPUTOUTPUTINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(NOINPUTOUTPUTINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl NoInputOutputInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NOINPUTOUTPUTINPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NoInputOutputInput {

     #[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 NoInputOutputInput {
     /// 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(&NOINPUTOUTPUTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&NOINPUTOUTPUTINPUT_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 NoInputOutputInput {
     /// 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 NoInputOutputInput {
     /// Creates a new builder-style object to manufacture [`NoInputOutputInput`](crate::operation::no_input_output::NoInputOutputInput).
     pub fn builder() -> crate::operation::no_input_output::builders::NoInputOutputInputBuilder {
         crate::operation::no_input_output::builders::NoInputOutputInputBuilder::default()
-68
+    }
-69
+}
-70
 /// A builder for [`NoInputOutputInput`](crate::operation::no_input_output::NoInputOutputInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct NoInputOutputInputBuilder {}
 impl NoInputOutputInputBuilder {
     /// Consumes the builder and constructs a [`NoInputOutputInput`](crate::operation::no_input_output::NoInputOutputInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::no_input_output::NoInputOutputInput, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::no_input_output::NoInputOutputInput {})
-81
+    }
-82
+}

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/no_input_output/_no_input_output_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 NoInputOutputOutput {}
 static NOINPUTOUTPUTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#NoInputOutputOutput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "NoInputOutputOutput",
 );
 static NOINPUTOUTPUTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(NOINPUTOUTPUTOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl NoInputOutputOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &NOINPUTOUTPUTOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NoInputOutputOutput {

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

↧ Expand context

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

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/operation_with_defaults.rs

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

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

@@ -110,114 +172,177 @@

↥ Expand context

         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "OperationWithDefaults",
             "RpcV2Protocol",
         ));
-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("OperationWithDefaults")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(OperationWithDefaultsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::operation_with_defaults::OperationWithDefaultsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::operation_with_defaults::OperationWithDefaultsError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct OperationWithDefaultsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationWithDefaultsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-161
+    }
-162
+}
 #[derive(Debug)]
 struct OperationWithDefaultsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OperationWithDefaultsRequestSerializer {
     #[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_defaults::OperationWithDefaultsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -510,515 +570,579 @@

↥ Expand context

             .set_zero_long(::std::option::Option::Some(0))
             .set_zero_float(::std::option::Option::Some(0.0_f32))
             .set_zero_double(::std::option::Option::Some(0.0_f64))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v/8="))
                 .unwrap(),
-526
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-530
         let op = crate::operation::operation_with_defaults::OperationWithDefaults::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");
-536
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::operation_with_defaults::OperationWithDefaultsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.default_string,
             expected_output.default_string,
             "Unexpected value for `default_string`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.default_boolean,
             expected_output.default_boolean,
             "Unexpected value for `default_boolean`"
         );
         ::pretty_assertions::assert_eq!(parsed.default_list, expected_output.default_list, "Unexpected value for `default_list`");
         ::pretty_assertions::assert_eq!(
             parsed.default_timestamp,
             expected_output.default_timestamp,
             "Unexpected value for `default_timestamp`"
         );
         ::pretty_assertions::assert_eq!(parsed.default_blob, expected_output.default_blob, "Unexpected value for `default_blob`");
         ::pretty_assertions::assert_eq!(parsed.default_byte, expected_output.default_byte, "Unexpected value for `default_byte`");
         ::pretty_assertions::assert_eq!(
             parsed.default_short,
             expected_output.default_short,
             "Unexpected value for `default_short`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.default_integer,

@@ -649,658 +709,722 @@

↥ Expand context

             .set_zero_short(::std::option::Option::Some(1))
             .set_zero_integer(::std::option::Option::Some(1))
             .set_zero_long(::std::option::Option::Some(1))
             .set_zero_float(::std::option::Option::Some(1.0_f32))
             .set_zero_double(::std::option::Option::Some(1.0_f64))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/cbor")
         .header("smithy-protocol", "rpc-v2-cbor")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("v21kZWZhdWx0U3RyaW5nY2J5ZW5kZWZhdWx0Qm9vbGVhbvRrZGVmYXVsdExpc3SBYWFwZGVmYXVsdFRpbWVzdGFtcMH7QAAAAAAAAABrZGVmYXVsdEJsb2JCaGlrZGVmYXVsdEJ5dGUCbGRlZmF1bHRTaG9ydAJuZGVmYXVsdEludGVnZXIUa2RlZmF1bHRMb25nGMhsZGVmYXVsdEZsb2F0+kAAAABtZGVmYXVsdERvdWJsZftAAAAAAAAAAGpkZWZhdWx0TWFwoWRuYW1lZEphY2trZGVmYXVsdEVudW1jQkFSbmRlZmF1bHRJbnRFbnVtAmtlbXB0eVN0cmluZ2Nmb29sZmFsc2VCb29sZWFu9WllbXB0eUJsb2JCaGloemVyb0J5dGUBaXplcm9TaG9ydAFremVyb0ludGVnZXIBaHplcm9Mb25nAWl6ZXJvRmxvYXT6P4AAAGp6ZXJvRG91Ymxl+z/wAAAAAAAA/w=="))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-673
         let op = crate::operation::operation_with_defaults::OperationWithDefaults::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-679
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::operation_with_defaults::OperationWithDefaultsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.default_string,
             expected_output.default_string,
             "Unexpected value for `default_string`"
         );

↧ Expand context

         ::pretty_assertions::assert_eq!(
             parsed.default_boolean,
             expected_output.default_boolean,
             "Unexpected value for `default_boolean`"
         );
         ::pretty_assertions::assert_eq!(parsed.default_list, expected_output.default_list, "Unexpected value for `default_list`");
         ::pretty_assertions::assert_eq!(
             parsed.default_timestamp,
             expected_output.default_timestamp,
             "Unexpected value for `default_timestamp`"
         );
         ::pretty_assertions::assert_eq!(parsed.default_blob, expected_output.default_blob, "Unexpected value for `default_blob`");
         ::pretty_assertions::assert_eq!(parsed.default_byte, expected_output.default_byte, "Unexpected value for `default_byte`");
         ::pretty_assertions::assert_eq!(
             parsed.default_short,
             expected_output.default_short,
             "Unexpected value for `default_short`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.default_integer,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/operation_with_defaults/_operation_with_defaults_input.rs

@@ -25,25 +179,190 @@

↥ Expand context

     pub fn top_level_default(&self) -> ::std::option::Option<&str> {
         self.top_level_default.as_deref()
-27
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn other_top_level_default(&self) -> ::std::option::Option<i32> {
         self.other_top_level_default
-31
+    }
-32
+}
 static OPERATIONWITHDEFAULTSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsInput",
     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "OperationWithDefaultsInput",
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_DEFAULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsInput$defaults",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,

     "defaults",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_CLIENT_OPTIONAL_DEFAULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsInput$clientOptionalDefaults",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "client_optional_defaults",
     "clientOptionalDefaults",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_TOP_LEVEL_DEFAULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsInput$topLevelDefault",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "top_level_default",
     "topLevelDefault",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_OTHER_TOP_LEVEL_DEFAULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsInput$otherTopLevelDefault",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "other_top_level_default",
     "otherTopLevelDefault",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     OPERATIONWITHDEFAULTSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_DEFAULTS,
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_CLIENT_OPTIONAL_DEFAULTS,
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_TOP_LEVEL_DEFAULT,
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_OTHER_TOP_LEVEL_DEFAULT,
     ],
 );
 impl OperationWithDefaultsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OPERATIONWITHDEFAULTSINPUT_SCHEMA;
-91
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithDefaultsInput {
     #[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.defaults {
             ser.write_struct(&OPERATIONWITHDEFAULTSINPUT_MEMBER_DEFAULTS, val)?;
-100
+        }
         if let Some(ref val) = self.client_optional_defaults {
             ser.write_struct(&OPERATIONWITHDEFAULTSINPUT_MEMBER_CLIENT_OPTIONAL_DEFAULTS, val)?;
-103
+        }
         if let Some(ref val) = self.top_level_default {
             ser.write_string(&OPERATIONWITHDEFAULTSINPUT_MEMBER_TOP_LEVEL_DEFAULT, val)?;
-106
+        }
         if let Some(ref val) = self.other_top_level_default {
             ser.write_integer(&OPERATIONWITHDEFAULTSINPUT_MEMBER_OTHER_TOP_LEVEL_DEFAULT, *val)?;
-109
+        }
         Ok(())
-111
+    }
-112
+}
 impl OperationWithDefaultsInput {
     /// 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(&OPERATIONWITHDEFAULTSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONWITHDEFAULTSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.defaults = Some(crate::types::Defaults::deserialize(deser)?);
-131
+                }
                 Some(1) => {
                     builder.client_optional_defaults = Some(crate::types::ClientOptionalDefaults::deserialize(deser)?);
-134
+                }
                 Some(2) => {
                     builder.top_level_default = Some(deser.read_string(member)?);
-137
+                }
                 Some(3) => {
                     builder.other_top_level_default = Some(deser.read_integer(member)?);
-140
+                }
                 _ => {}
-142
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-148
+    }
-149
+}
 impl OperationWithDefaultsInput {
     /// 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 OperationWithDefaultsInput {
     /// Creates a new builder-style object to manufacture [`OperationWithDefaultsInput`](crate::operation::operation_with_defaults::OperationWithDefaultsInput).
     pub fn builder() -> crate::operation::operation_with_defaults::builders::OperationWithDefaultsInputBuilder {
         crate::operation::operation_with_defaults::builders::OperationWithDefaultsInputBuilder::default()
-165
+    }
-166
+}
-167
 /// A builder for [`OperationWithDefaultsInput`](crate::operation::operation_with_defaults::OperationWithDefaultsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithDefaultsInputBuilder {
     pub(crate) defaults: ::std::option::Option<crate::types::Defaults>,
     pub(crate) client_optional_defaults: ::std::option::Option<crate::types::ClientOptionalDefaults>,
     pub(crate) top_level_default: ::std::option::Option<::std::string::String>,
     pub(crate) other_top_level_default: ::std::option::Option<i32>,
-176
+}
 impl OperationWithDefaultsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn defaults(mut self, input: crate::types::Defaults) -> Self {
         self.defaults = ::std::option::Option::Some(input);
         self
-182
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_defaults(mut self, input: ::std::option::Option<crate::types::Defaults>) -> Self {
         self.defaults = input;
         self
-187
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_defaults(&self) -> &::std::option::Option<crate::types::Defaults> {
         &self.defaults

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/operation_with_defaults/_operation_with_defaults_output.rs

@@ -132,132 +412,412 @@

↥ Expand context

-132
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_integer(&self) -> i32 {
         self.zero_integer
-136
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_long(&self) -> i64 {
         self.zero_long
-140
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_float(&self) -> f32 {
         self.zero_float
-144
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_double(&self) -> f64 {
         self.zero_double
-148
+    }
-149
+}
 static OPERATIONWITHDEFAULTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput",

     "smithy.protocoltests.rpcv2Cbor.synthetic",
     "OperationWithDefaultsOutput",
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultString",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "default_string",
     "defaultString",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultBoolean",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "default_boolean",
     "defaultBoolean",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultList",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "default_list",
     "defaultList",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultTimestamp",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "default_timestamp",
     "defaultTimestamp",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultBlob",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "default_blob",
     "defaultBlob",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultByte",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "default_byte",
     "defaultByte",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultShort",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "default_short",
     "defaultShort",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultInteger",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "default_integer",
     "defaultInteger",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultLong",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "default_long",
     "defaultLong",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultFloat",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "default_float",
     "defaultFloat",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultDouble",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "default_double",
     "defaultDouble",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultMap",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "default_map",
     "defaultMap",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultEnum",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "default_enum",
     "defaultEnum",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$defaultIntEnum",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "default_int_enum",
     "defaultIntEnum",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$emptyString",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "empty_string",
     "emptyString",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_FALSE_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$falseBoolean",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "false_boolean",
     "falseBoolean",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$emptyBlob",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "empty_blob",
     "emptyBlob",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$zeroByte",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "zero_byte",
     "zeroByte",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$zeroShort",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "zero_short",
     "zeroShort",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$zeroInteger",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "zero_integer",
     "zeroInteger",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$zeroLong",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "zero_long",
     "zeroLong",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$zeroFloat",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "zero_float",
     "zeroFloat",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "smithy.protocoltests.rpcv2Cbor.synthetic#OperationWithDefaultsOutput$zeroDouble",
         "smithy.protocoltests.rpcv2Cbor.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "zero_double",
     "zeroDouble",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     OPERATIONWITHDEFAULTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_STRING,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BOOLEAN,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_TIMESTAMP,

↧ Expand context

         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BLOB,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BYTE,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_SHORT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INTEGER,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LONG,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_FLOAT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOUBLE,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_ENUM,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INT_ENUM,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_STRING,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_FALSE_BOOLEAN,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_BLOB,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_BYTE,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_SHORT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_INTEGER,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_LONG,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_FLOAT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_DOUBLE,
     ],

@@ -510,510 +679,670 @@

↥ Expand context

-510
+        }
-511
+        {
             let val = &self.zero_byte;
             ser.write_byte(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_BYTE, *val)?;
-514
+        }
-515
+        {
             let val = &self.zero_short;
             ser.write_short(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_SHORT, *val)?;
-518
+        }
-519
+        {
             let val = &self.zero_integer;
             ser.write_integer(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_INTEGER, *val)?;
-522
+        }
-523
+        {
             let val = &self.zero_long;
             ser.write_long(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_LONG, *val)?;
-526
+        }
-527
+        {
             let val = &self.zero_float;
             ser.write_float(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_FLOAT, *val)?;

-530
+        }
-531
+        {
             let val = &self.zero_double;
             ser.write_double(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_DOUBLE, *val)?;
-534
+        }
         Ok(())
-536
+    }
-537
+}
 impl OperationWithDefaultsOutput {
     /// 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(&OPERATIONWITHDEFAULTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONWITHDEFAULTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.default_string = Some(deser.read_string(member)?);
-556
+                }
                 Some(1) => {
                     builder.default_boolean = Some(deser.read_boolean(member)?);
-559
+                }
                 Some(2) => {
                     builder.default_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.default_list = Some(deser.read_string_list(member)?);
-562
+                }
                 Some(3) => {
                     builder.default_timestamp = Some(deser.read_timestamp(member)?);
-565
+                }
                 Some(4) => {
                     builder.default_blob = Some(deser.read_blob(member)?);
-568
+                }
                 Some(5) => {
                     builder.default_byte = Some(deser.read_byte(member)?);
-571
+                }
                 Some(6) => {
                     builder.default_short = Some(deser.read_short(member)?);
-574
+                }
                 Some(7) => {
                     builder.default_integer = Some(deser.read_integer(member)?);
-577
+                }
                 Some(8) => {
                     builder.default_long = Some(deser.read_long(member)?);
-580
+                }
                 Some(9) => {
                     builder.default_float = Some(deser.read_float(member)?);
-583
+                }
                 Some(10) => {
                     builder.default_double = Some(deser.read_double(member)?);
-586
+                }
                 Some(11) => {
                     builder.default_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.default_map = Some(deser.read_string_string_map(member)?);
-589
+                }
                 Some(12) => {
                     builder.default_enum = Some(crate::types::TestEnum::from(deser.read_string(member)?.as_str()));
-592
+                }
                 Some(13) => {
                     builder.default_int_enum = Some(deser.read_integer(member)?);
-595
+                }
                 Some(14) => {
                     builder.empty_string = Some(deser.read_string(member)?);
-598
+                }
                 Some(15) => {
                     builder.false_boolean = Some(deser.read_boolean(member)?);
-601
+                }
                 Some(16) => {
                     builder.empty_blob = Some(deser.read_blob(member)?);
-604
+                }
                 Some(17) => {
                     builder.zero_byte = Some(deser.read_byte(member)?);
-607
+                }
                 Some(18) => {
                     builder.zero_short = Some(deser.read_short(member)?);
-610
+                }
                 Some(19) => {
                     builder.zero_integer = Some(deser.read_integer(member)?);
-613
+                }
                 Some(20) => {
                     builder.zero_long = Some(deser.read_long(member)?);
-616
+                }
                 Some(21) => {
                     builder.zero_float = Some(deser.read_float(member)?);
-619
+                }
                 Some(22) => {
                     builder.zero_double = Some(deser.read_double(member)?);
-622
+                }
                 _ => {}
-624
+            }
             Ok(())
         })?;
         Ok(builder.build())
-628
+    }
-629
+}
 impl OperationWithDefaultsOutput {
     /// 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 OperationWithDefaultsOutput {
     /// Creates a new builder-style object to manufacture [`OperationWithDefaultsOutput`](crate::operation::operation_with_defaults::OperationWithDefaultsOutput).
     pub fn builder() -> crate::operation::operation_with_defaults::builders::OperationWithDefaultsOutputBuilder {
         crate::operation::operation_with_defaults::builders::OperationWithDefaultsOutputBuilder::default()
-645
+    }
-646
+}
-647
 /// A builder for [`OperationWithDefaultsOutput`](crate::operation::operation_with_defaults::OperationWithDefaultsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithDefaultsOutputBuilder {
     pub(crate) default_string: ::std::option::Option<::std::string::String>,
     pub(crate) default_boolean: ::std::option::Option<bool>,
     pub(crate) default_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) default_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) default_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) default_byte: ::std::option::Option<i8>,
     pub(crate) default_short: ::std::option::Option<i16>,
     pub(crate) default_integer: ::std::option::Option<i32>,
     pub(crate) default_long: ::std::option::Option<i64>,
     pub(crate) default_float: ::std::option::Option<f32>,
     pub(crate) default_double: ::std::option::Option<f64>,
     pub(crate) default_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) default_enum: ::std::option::Option<crate::types::TestEnum>,
     pub(crate) default_int_enum: ::std::option::Option<i32>,
     pub(crate) empty_string: ::std::option::Option<::std::string::String>,
     pub(crate) false_boolean: ::std::option::Option<bool>,
     pub(crate) empty_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) zero_byte: ::std::option::Option<i8>,
     pub(crate) zero_short: ::std::option::Option<i16>,

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/optional_input_output.rs

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

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

@@ -104,108 +166,171 @@

↥ Expand context

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

                 crate::operation::optional_input_output::OptionalInputOutputError,
             >::new());
-130
         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct OptionalInputOutputResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OptionalInputOutputResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-148
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_optional_input_output::de_optional_input_output_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_optional_input_output::de_optional_input_output_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-155
+    }
-156
+}
 #[derive(Debug)]
 struct OptionalInputOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OptionalInputOutputRequestSerializer {
     #[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::optional_input_output::OptionalInputOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

@@ -285,290 +345,354 @@

↥ Expand context

     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn optional_output_response() {
         let expected_output = crate::operation::optional_input_output::OptionalInputOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/cbor")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("v/8="))
                 .unwrap(),
-301
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-305
         let op = crate::operation::optional_input_output::OptionalInputOutput::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");
-311
         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/cbor"),
                 )))
             });
             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();
-+
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::optional_input_output::OptionalInputOutputOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.value, expected_output.value, "Unexpected value for `value`");
-331
+    }
-332
+}
-333
 /// Error type for the `OptionalInputOutputError` operation.

↧ Expand context

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

Client Test

Files changed: