Client Test

rev. bbca34fa2eddb4be623fbbc6b6df1a2401de0029

Files changed:

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

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

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

↧ Expand context

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

@@ -111,115 +231,243 @@

↥ Expand context

         _: &::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("JsonUnions")
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
             ))
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 JsonUnionsEndpointParamsInterceptor,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::json_unions::JsonUnionsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::json_unions::JsonUnionsError,
             >::new());
-131
         ::std::borrow::Cow::Owned(rcb)
-133
+    }
-134
+}

-135
 #[derive(Debug)]
 struct JsonUnionsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for JsonUnionsResponseDeserializer {
     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();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-153
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_json_unions::de_json_unions_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(crate::operation::json_unions::JsonUnionsError::generic(
                     generic,
                 )),
             ))
         } else {
             crate::protocol_serde::shape_json_unions::de_json_unions_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, JsonUnions::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::json_unions::JsonUnionsOutput::deserialize_with_response(
                 &mut *deser,
                 _response_headers,
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-193
+    }
-194
+}
 #[derive(Debug)]
 struct JsonUnionsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for JsonUnionsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::json_unions::JsonUnionsInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::json_unions::JsonUnionsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::json_unions::JsonUnionsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.JsonUnions",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_json_unions::ser_json_unions_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, JsonUnions::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-214
+    }
-215
+}
 #[derive(Debug)]
 struct JsonUnionsEndpointParamsInterceptor;
-218
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for JsonUnionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "JsonUnionsEndpointParamsInterceptor"
-223
+    }

↧ Expand context

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

@@ -602,614 +1203,1299 @@

↥ Expand context

     /// Deserializes a string union value
     /// Test ID: AwsJson10DeserializeStringUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_string_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
                 ))
                 .unwrap(),
-630
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-634
         let op = crate::operation::json_unions::JsonUnions::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");
-640
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-651
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-667
+    }
-668
     /// Deserializes a boolean union value
     /// Test ID: AwsJson10DeserializeBooleanUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_boolean_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
                 ))
                 .unwrap(),
-685
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-689
         let op = crate::operation::json_unions::JsonUnions::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");
-695
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-706
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-722
+    }
-723
     /// Deserializes a number union value
     /// Test ID: AwsJson10DeserializeNumberUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_number_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
                 ))
                 .unwrap(),
-740
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-744
         let op = crate::operation::json_unions::JsonUnions::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");
-750
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-761
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-777
+    }
-778
     /// Deserializes a blob union value
     /// Test ID: AwsJson10DeserializeBlobUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_blob_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
                 ::aws_smithy_types::Blob::new("foo"),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
                 ))
                 .unwrap(),
-797
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-801
         let op = crate::operation::json_unions::JsonUnions::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");
-807
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-818
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-834
+    }
-835
     /// Deserializes a timestamp union value
     /// Test ID: AwsJson10DeserializeTimestampUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_timestamp_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
                 ))
                 .unwrap(),
-854
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-858
         let op = crate::operation::json_unions::JsonUnions::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");
-864
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-875
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-891
+    }
-892
     /// Deserializes an enum union value
     /// Test ID: AwsJson10DeserializeEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_enum_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
                 "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
                 ))
                 .unwrap(),
-911
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-915
         let op = crate::operation::json_unions::JsonUnions::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");
-921
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-932
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-948
+    }
-949
     /// Deserializes an intEnum union value
     /// Test ID: AwsJson10DeserializeIntEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_int_enum_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::IntEnumValue(1)))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"intEnumValue\": 1\n    }\n}",
                 ))
                 .unwrap(),
-966
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-970
         let op = crate::operation::json_unions::JsonUnions::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");
-976
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-987
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1003
+    }
-1004
     /// Deserializes a list union value
     /// Test ID: AwsJson10DeserializeListUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_list_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".to_owned(),
             ])))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
                 ))
                 .unwrap(),
-1024
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1028
         let op = crate::operation::json_unions::JsonUnions::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");
-1034
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1045
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1061
+    }
-1062
     /// Deserializes a map union value
     /// Test ID: AwsJson10DeserializeMapUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_map_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), "bar".to_owned());
                 ret.insert("spam".to_owned(), "eggs".to_owned());
                 ret
             })))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http_1x::response::Builder::new()
         .header("Content-Type", "application/x-amz-json-1.0")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1084
         let op = crate::operation::json_unions::JsonUnions::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");
-1090
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1101
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1117
+    }
-1118
     /// Deserializes a structure union value
     /// Test ID: AwsJson10DeserializeStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_structure_union_value_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".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/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}",
                 ))
                 .unwrap(),
-1139
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1143
         let op = crate::operation::json_unions::JsonUnions::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");
-1149
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1160
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1176
+    }
-1177
     /// Ignores an unrecognized __type property
     /// Test ID: AwsJson10DeserializeIgnoreType
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_ignore_type_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".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/x-amz-json-1.0")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n        \"__type\": \"aws.protocoltests.json10#MyUnion\",\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1198
         let op = crate::operation::json_unions::JsonUnions::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");
-1204
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1215
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1231
+    }
-1232
     /// Allows for `: null` to be set for all unset fields
     /// Test ID: AwsJson10DeserializeAllowNulls
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_deserialize_allow_nulls_response() {
         let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
             .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
                 crate::types::GreetingStruct::builder()
                     .set_hi(::std::option::Option::Some("hello".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/x-amz-json-1.0")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"contents\": {\n      \"stringValue\": null,\n      \"booleanValue\": null,\n      \"numberValue\": null,\n      \"blobValue\": null,\n      \"timestampValue\": null,\n      \"enumValue\": null,\n      \"intEnumValue\": null,\n      \"listValue\": null,\n      \"mapValue\": null,\n      \"structureValue\": {\n          \"hi\": \"hello\"\n      }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-1253
         let op = crate::operation::json_unions::JsonUnions::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");
-1259
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-1270
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
-1286
+    }
-1287
+}
-1288
 /// Error type for the `JsonUnionsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum JsonUnionsError {
     /// 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()`:
-1296
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-1298
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-JsonUnionsError) for what information is available for the error.")]

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

@@ -1,1 +44,122 @@

↥ 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 JsonUnionsInput {
     /// A union with a representative set of types for members.
     pub contents: ::std::option::Option<crate::types::MyUnion>,
-8
+}
 impl JsonUnionsInput {
     /// A union with a representative set of types for members.
     pub fn contents(&self) -> ::std::option::Option<&crate::types::MyUnion> {
         self.contents.as_ref()
-13
+    }
-14
+}
 static JSONUNIONSINPUT_MEMBER_CONTENTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#JsonUnionsInput$contents",
         "aws.protocoltests.json10.synthetic",
         "JsonUnionsInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "contents",
 ,
 );
 static JSONUNIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#JsonUnionsInput",
         "aws.protocoltests.json10.synthetic",
         "JsonUnionsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&JSONUNIONSINPUT_MEMBER_CONTENTS],
-+
+)
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
 .with_original_name("JsonUnionsInput");
 impl JsonUnionsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &JSONUNIONSINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonUnionsInput {
     #[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.contents {
             ser.write_struct(&JSONUNIONSINPUT_MEMBER_CONTENTS, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl JsonUnionsInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&JSONUNIONSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.contents = Some(crate::types::MyUnion::deserialize(deser)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl JsonUnionsInput {
     /// 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 JsonUnionsInput {
     /// Creates a new builder-style object to manufacture [`JsonUnionsInput`](crate::operation::json_unions::JsonUnionsInput).
     pub fn builder() -> crate::operation::json_unions::builders::JsonUnionsInputBuilder {
         crate::operation::json_unions::builders::JsonUnionsInputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`JsonUnionsInput`](crate::operation::json_unions::JsonUnionsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonUnionsInputBuilder {
     pub(crate) contents: ::std::option::Option<crate::types::MyUnion>,
-105
+}
 impl JsonUnionsInputBuilder {
     /// A union with a representative set of types for members.
     pub fn contents(mut self, input: crate::types::MyUnion) -> Self {
         self.contents = ::std::option::Option::Some(input);
         self
-111
+    }
     /// A union with a representative set of types for members.
     pub fn set_contents(mut self, input: ::std::option::Option<crate::types::MyUnion>) -> Self {
         self.contents = input;
         self
-116
+    }
     /// A union with a representative set of types for members.
     pub fn get_contents(&self) -> &::std::option::Option<crate::types::MyUnion> {
         &self.contents
-120
+    }
     /// Consumes the builder and constructs a [`JsonUnionsInput`](crate::operation::json_unions::JsonUnionsInput).
     pub fn build(self) -> ::std::result::Result<crate::operation::json_unions::JsonUnionsInput, ::aws_smithy_types::error::operation::BuildError> {

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

@@ -1,1 +44,121 @@

↥ Expand context

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

 pub struct JsonUnionsOutput {
     /// A union with a representative set of types for members.
     pub contents: ::std::option::Option<crate::types::MyUnion>,
-8
+}
 impl JsonUnionsOutput {
     /// A union with a representative set of types for members.
     pub fn contents(&self) -> ::std::option::Option<&crate::types::MyUnion> {
         self.contents.as_ref()
-13
+    }
-14
+}
 static JSONUNIONSOUTPUT_MEMBER_CONTENTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#JsonUnionsOutput$contents",
         "aws.protocoltests.json10.synthetic",
         "JsonUnionsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "contents",
 ,
 );
 static JSONUNIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#JsonUnionsOutput",
         "aws.protocoltests.json10.synthetic",
         "JsonUnionsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&JSONUNIONSOUTPUT_MEMBER_CONTENTS],
-+
+)
 .with_original_name("JsonUnionsOutput");
 impl JsonUnionsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &JSONUNIONSOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for JsonUnionsOutput {
     #[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.contents {
             ser.write_struct(&JSONUNIONSOUTPUT_MEMBER_CONTENTS, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl JsonUnionsOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&JSONUNIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.contents = Some(crate::types::MyUnion::deserialize(deser)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl JsonUnionsOutput {
     /// 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 JsonUnionsOutput {
     /// Creates a new builder-style object to manufacture [`JsonUnionsOutput`](crate::operation::json_unions::JsonUnionsOutput).
     pub fn builder() -> crate::operation::json_unions::builders::JsonUnionsOutputBuilder {
         crate::operation::json_unions::builders::JsonUnionsOutputBuilder::default()
-96
+    }
-97
+}
-98
 /// A builder for [`JsonUnionsOutput`](crate::operation::json_unions::JsonUnionsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct JsonUnionsOutputBuilder {
     pub(crate) contents: ::std::option::Option<crate::types::MyUnion>,
-104
+}
 impl JsonUnionsOutputBuilder {
     /// A union with a representative set of types for members.
     pub fn contents(mut self, input: crate::types::MyUnion) -> Self {
         self.contents = ::std::option::Option::Some(input);
         self
-110
+    }
     /// A union with a representative set of types for members.
     pub fn set_contents(mut self, input: ::std::option::Option<crate::types::MyUnion>) -> Self {
         self.contents = input;
         self
-115
+    }
     /// A union with a representative set of types for members.
     pub fn get_contents(&self) -> &::std::option::Option<crate::types::MyUnion> {
         &self.contents
-119
+    }
     /// Consumes the builder and constructs a [`JsonUnionsOutput`](crate::operation::json_unions::JsonUnionsOutput).
     pub fn build(self) -> crate::operation::json_unions::JsonUnionsOutput {

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

@@ -1,1 +40,45 @@

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

@@ -114,119 +235,251 @@

↥ Expand context

         _: &::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("NoInputAndNoOutput")
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
             ))
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 NoInputAndNoOutputEndpointParamsInterceptor,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::no_input_and_no_output::NoInputAndNoOutputError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::no_input_and_no_output::NoInputAndNoOutputError,
             >::new());
-135
         ::std::borrow::Cow::Owned(rcb)
-137
+    }
-138
+}

-139
 #[derive(Debug)]
 struct NoInputAndNoOutputResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for NoInputAndNoOutputResponseDeserializer {
     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();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-157
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::no_input_and_no_output::NoInputAndNoOutputError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, NoInputAndNoOutput::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::deserialize_with_response(
                 &mut *deser,
                 _response_headers,
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-199
+    }
-200
+}
 #[derive(Debug)]
 struct NoInputAndNoOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for NoInputAndNoOutputRequestSerializer {
     #[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_and_no_output::NoInputAndNoOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::no_input_and_no_output::NoInputAndNoOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::no_input_and_no_output::NoInputAndNoOutputInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.NoInputAndNoOutput",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_input(
             &input,
         )?);
-213
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, NoInputAndNoOutput::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-222
+    }
-223
+}
 #[derive(Debug)]
 struct NoInputAndNoOutputEndpointParamsInterceptor;
-226
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndNoOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndNoOutputEndpointParamsInterceptor"
-231
+    }

↧ Expand context

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

@@ -285,301 +437,474 @@

↥ Expand context

-301
     /// When no output is defined, the service is expected to return
     /// an empty payload, however, client must ignore a JSON payload
     /// if one is returned. This ensures that if output is added later,
     /// then it will not break the client.
     /// Test ID: AwsJson10HandlesEmptyOutputShape
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_handles_empty_output_shape_response() {
         let expected_output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-317
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-321
         let op = crate::operation::no_input_and_no_output::NoInputAndNoOutput::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");
-327
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-338
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput>()
             .unwrap();
-353
+    }
-354
     /// This client-only test builds on handles_empty_output_shape,
     /// by including unexpected fields in the JSON. A client
     /// needs to ignore JSON output that is empty or that contains
     /// JSON object data.
     /// Test ID: AwsJson10HandlesUnexpectedJsonOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_handles_unexpected_json_output_response() {
         let expected_output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"foo\": true\n}"))
                 .unwrap(),
-370
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-374
         let op = crate::operation::no_input_and_no_output::NoInputAndNoOutput::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-380
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-391
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput>()
             .unwrap();
-406
+    }
-407
     /// When no output is defined, the service is expected to return
     /// an empty payload. Despite the lack of a payload, the service
     /// is expected to always send a Content-Type header. Clients must
     /// handle cases where a service returns a JSON object and where
     /// a service returns no JSON at all.
     /// Test ID: AwsJson10ServiceRespondsWithNoPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_service_responds_with_no_payload_response() {
         let expected_output = crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-424
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-428
         let op = crate::operation::no_input_and_no_output::NoInputAndNoOutput::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");
-434
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-445
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput>()
             .unwrap();
-460
+    }
-461
+}
-462
 /// Error type for the `NoInputAndNoOutputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum NoInputAndNoOutputError {
     /// 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()`:
-470
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-472
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-NoInputAndNoOutputError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),

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

@@ -1,1 +25,85 @@

 // 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 NoInputAndNoOutputInput {}
 static NOINPUTANDNOOUTPUTINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#NoInputAndNoOutputInput",
         "aws.protocoltests.json10.synthetic",
         "NoInputAndNoOutputInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
-+
+)
 .with_no_body_members()
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload);
 impl NoInputAndNoOutputInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &NOINPUTANDNOOUTPUTINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NoInputAndNoOutputInput {
     #[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(())
-+
+    }
-+
+}
 impl NoInputAndNoOutputInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&NOINPUTANDNOOUTPUTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl NoInputAndNoOutputInput {
     /// 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(e.to_string()))
-+
+    }
-+
+}
 impl NoInputAndNoOutputInput {
     /// Creates a new builder-style object to manufacture [`NoInputAndNoOutputInput`](crate::operation::no_input_and_no_output::NoInputAndNoOutputInput).
     pub fn builder() -> crate::operation::no_input_and_no_output::builders::NoInputAndNoOutputInputBuilder {
         crate::operation::no_input_and_no_output::builders::NoInputAndNoOutputInputBuilder::default()
-70
+    }
-71
+}
-72
 /// A builder for [`NoInputAndNoOutputInput`](crate::operation::no_input_and_no_output::NoInputAndNoOutputInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

@@ -1,1 +22,78 @@

 // 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 NoInputAndNoOutputOutput {}
 static NOINPUTANDNOOUTPUTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#NoInputAndNoOutputOutput",
         "aws.protocoltests.json10.synthetic",
         "NoInputAndNoOutputOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
 );
 impl NoInputAndNoOutputOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &NOINPUTANDNOOUTPUTOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NoInputAndNoOutputOutput {
     #[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(())
-+
+    }
-+
+}
 impl NoInputAndNoOutputOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&NOINPUTANDNOOUTPUTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl NoInputAndNoOutputOutput {
     /// 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 NoInputAndNoOutputOutput {
     /// Creates a new builder-style object to manufacture [`NoInputAndNoOutputOutput`](crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput).
     pub fn builder() -> crate::operation::no_input_and_no_output::builders::NoInputAndNoOutputOutputBuilder {
         crate::operation::no_input_and_no_output::builders::NoInputAndNoOutputOutputBuilder::default()
-66
+    }
-67
+}
-68
 /// A builder for [`NoInputAndNoOutputOutput`](crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct NoInputAndNoOutputOutputBuilder {}
 impl NoInputAndNoOutputOutputBuilder {
     /// Consumes the builder and constructs a [`NoInputAndNoOutputOutput`](crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput).
     pub fn build(self) -> crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput {
         crate::operation::no_input_and_no_output::NoInputAndNoOutputOutput {}
-77
+    }
-78
+}

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/no_input_and_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 `NoInputAndOutput`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct NoInputAndOutput;
 impl NoInputAndOutput {
     /// Creates a new `NoInputAndOutput`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = crate::operation::no_input_and_output::NoInputAndOutputInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = crate::operation::no_input_and_output::NoInputAndOutputOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::no_input_and_output::NoInputAndOutputInput,
     ) -> ::std::result::Result<
         crate::operation::no_input_and_output::NoInputAndOutputOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::no_input_and_output::NoInputAndOutputError,
             ::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_and_output::NoInputAndOutputError>()
                     .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_and_output::NoInputAndOutputOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -114,118 +233,250 @@

↥ Expand context

         _: &::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("NoInputAndOutput")
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
             ))
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 NoInputAndOutputEndpointParamsInterceptor,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::no_input_and_output::NoInputAndOutputError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::no_input_and_output::NoInputAndOutputError,
             >::new());
-134
         ::std::borrow::Cow::Owned(rcb)
-136
+    }
-137
+}

-138
 #[derive(Debug)]
 struct NoInputAndOutputResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for NoInputAndOutputResponseDeserializer {
     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();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-156
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::no_input_and_output::NoInputAndOutputError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, NoInputAndOutput::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::no_input_and_output::NoInputAndOutputOutput::deserialize_with_response(
                 &mut *deser,
                 _response_headers,
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-198
+    }
-199
+}
 #[derive(Debug)]
 struct NoInputAndOutputRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for NoInputAndOutputRequestSerializer {
     #[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_and_output::NoInputAndOutputInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::no_input_and_output::NoInputAndOutputInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::no_input_and_output::NoInputAndOutputInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.NoInputAndOutput",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_input(&input)?);
-212
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, NoInputAndOutput::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-221
+    }
-222
+}
 #[derive(Debug)]
 struct NoInputAndOutputEndpointParamsInterceptor;
-225
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for NoInputAndOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "NoInputAndOutputEndpointParamsInterceptor"
-230
+    }

↧ Expand context

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

@@ -275,292 +334,358 @@

↥ Expand context

         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
-294
+    }
-295
     /// Empty output always serializes an empty object payload.
     /// Test ID: AwsJson10NoInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json10_no_input_and_output_response() {
         let expected_output = crate::operation::no_input_and_output::NoInputAndOutputOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-308
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-312
         let op = crate::operation::no_input_and_output::NoInputAndOutput::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");
-318
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-329
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::no_input_and_output::NoInputAndOutputOutput>()
             .unwrap();
-344
+    }
-345
+}
-346
 /// Error type for the `NoInputAndOutputError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum NoInputAndOutputError {
     /// 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()`:
-354
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-356
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-NoInputAndOutputError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),

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

@@ -1,1 +24,84 @@

 // 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 NoInputAndOutputInput {}
 static NOINPUTANDOUTPUTINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#NoInputAndOutputInput",
         "aws.protocoltests.json10.synthetic",
         "NoInputAndOutputInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
-+
+)
 .with_no_body_members()
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload);
 impl NoInputAndOutputInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &NOINPUTANDOUTPUTINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NoInputAndOutputInput {
     #[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(())
-+
+    }
-+
+}
 impl NoInputAndOutputInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&NOINPUTANDOUTPUTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl NoInputAndOutputInput {
     /// 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(e.to_string()))
-+
+    }
-+
+}
 impl NoInputAndOutputInput {
     /// Creates a new builder-style object to manufacture [`NoInputAndOutputInput`](crate::operation::no_input_and_output::NoInputAndOutputInput).
     pub fn builder() -> crate::operation::no_input_and_output::builders::NoInputAndOutputInputBuilder {
         crate::operation::no_input_and_output::builders::NoInputAndOutputInputBuilder::default()
-70
+    }
-71
+}
-72
 /// A builder for [`NoInputAndOutputInput`](crate::operation::no_input_and_output::NoInputAndOutputInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

@@ -1,1 +22,79 @@

 // 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 NoInputAndOutputOutput {}
 static NOINPUTANDOUTPUTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#NoInputAndOutputOutput",
         "aws.protocoltests.json10.synthetic",
         "NoInputAndOutputOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[],
-+
+)
 .with_original_name("NoInputAndOutputOutput");
 impl NoInputAndOutputOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &NOINPUTANDOUTPUTOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for NoInputAndOutputOutput {
     #[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(())
-+
+    }
-+
+}
 impl NoInputAndOutputOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&NOINPUTANDOUTPUTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl NoInputAndOutputOutput {
     /// 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 NoInputAndOutputOutput {
     /// Creates a new builder-style object to manufacture [`NoInputAndOutputOutput`](crate::operation::no_input_and_output::NoInputAndOutputOutput).
     pub fn builder() -> crate::operation::no_input_and_output::builders::NoInputAndOutputOutputBuilder {
         crate::operation::no_input_and_output::builders::NoInputAndOutputOutputBuilder::default()
-67
+    }
-68
+}
-69
 /// A builder for [`NoInputAndOutputOutput`](crate::operation::no_input_and_output::NoInputAndOutputOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `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<'static> =
         crate::operation::operation_with_defaults::OperationWithDefaultsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
         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"),
-44
+        )
-45
+    }
-46

@@ -160,166 +284,298 @@

↥ Expand context

             .filter(|r| !r.is_empty())
         else {
             return ::std::result::Result::Ok(());
         };
-170
         let ::std::option::Option::Some(input) = context.input().downcast_ref::<OperationWithDefaultsInput>() else {
             // A mismatched input is not this interceptor's concern; skip quietly.
             return ::std::result::Result::Ok(());
         };
-175
         let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
         if requested.should_capture("topLevelDefault") {
             if let ::std::option::Option::Some(value) = input.top_level_default.as_deref() {
                 captured.insert("topLevelDefault", value);
-180
+            }
-181
+        }
-182
         cfg.interceptor_state().store_put(captured);
         ::std::result::Result::Ok(())
-185
+    }

-186
+}
 #[derive(Debug)]
 struct OperationWithDefaultsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationWithDefaultsResponseDeserializer {
     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();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-204
         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)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::operation_with_defaults::OperationWithDefaultsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, OperationWithDefaults::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::operation_with_defaults::OperationWithDefaultsOutput::deserialize_with_response(
                 &mut *deser,
                 _response_headers,
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-246
+    }
-247
+}
 #[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()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::operation_with_defaults::OperationWithDefaultsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::operation_with_defaults::OperationWithDefaultsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.OperationWithDefaults",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, OperationWithDefaults::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-269
+    }
-270
+}
 #[derive(Debug)]
 struct OperationWithDefaultsEndpointParamsInterceptor;
-273
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationWithDefaultsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationWithDefaultsEndpointParamsInterceptor"
-278
+    }

↧ Expand context

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

@@ -567,581 +626,647 @@

↥ Expand context

             .set_empty_string(::std::option::Option::Some("".to_owned()))
             .set_false_boolean(::std::option::Option::Some(false))
             .set_empty_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
             .set_zero_byte(::std::option::Option::Some(0))
             .set_zero_short(::std::option::Option::Some(0))
             .set_zero_integer(::std::option::Option::Some(0))
             .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/x-amz-json-1.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-597
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-601
         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");
-607
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-618
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         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`"
         );
         ::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_document_map,
             expected_output.default_document_map,
             "Unexpected value for `default_document_map`"

@@ -763,784 +822,850 @@

↥ Expand context

             ))
             .set_default_int_enum(::std::option::Option::Some(2))
             .set_empty_string(::std::option::Option::Some("foo".to_owned()))
             .set_false_boolean(::std::option::Option::Some(true))
             .set_empty_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("hi")))
             .set_zero_byte(::std::option::Option::Some(1))
             .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/x-amz-json-1.0")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"defaultString\": \"bye\",\n    \"defaultBoolean\": false,\n    \"defaultList\": [\"a\"],\n    \"defaultDocumentMap\": {\"name\": \"Jack\"},\n    \"defaultDocumentString\": \"bye\",\n    \"defaultDocumentBoolean\": false,\n    \"defaultDocumentList\": [\"b\"],\n    \"defaultNullDocument\": \"notNull\",\n    \"defaultTimestamp\": 2,\n    \"defaultBlob\": \"aGk=\",\n    \"defaultByte\": 2,\n    \"defaultShort\": 2,\n    \"defaultInteger\": 20,\n    \"defaultLong\": 200,\n    \"defaultFloat\": 2.0,\n    \"defaultDouble\": 2.0,\n    \"defaultMap\": {\"name\": \"Jack\"},\n    \"defaultEnum\": \"BAR\",\n    \"defaultIntEnum\": 2,\n    \"emptyString\": \"foo\",\n    \"falseBoolean\": true,\n    \"emptyBlob\": \"aGk=\",\n    \"zeroByte\": 1,\n    \"zeroShort\": 1,\n    \"zeroInteger\": 1,\n    \"zeroLong\": 1,\n    \"zeroFloat\": 1.0,\n    \"zeroDouble\": 1.0\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-804
         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");
-810
         // Build a config bag with the protocol for schema-based deserialization
         #[allow(unused_mut)]
         let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+        {
             let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
             layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                 ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-821
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         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`"
         );
         ::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_document_map,
             expected_output.default_document_map,
             "Unexpected value for `default_document_map`"

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

@@ -3,3 +62,205 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct OperationWithDefaultsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub defaults: ::std::option::Option<crate::types::Defaults>,
     #[allow(missing_docs)] // documentation missing in model
     pub client_optional_defaults: ::std::option::Option<crate::types::ClientOptionalDefaults>,
     #[allow(missing_docs)] // documentation missing in model
     pub top_level_default: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub other_top_level_default: ::std::option::Option<i32>,
-14
+}
 impl OperationWithDefaultsInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn defaults(&self) -> ::std::option::Option<&crate::types::Defaults> {
         self.defaults.as_ref()
-19
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn client_optional_defaults(&self) -> ::std::option::Option<&crate::types::ClientOptionalDefaults> {
         self.client_optional_defaults.as_ref()

-23
+    }
     #[allow(missing_docs)] // documentation missing in model
     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_MEMBER_DEFAULTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsInput$defaults",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "defaults",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_CLIENT_OPTIONAL_DEFAULTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsInput$clientOptionalDefaults",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "clientOptionalDefaults",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_TOP_LEVEL_DEFAULT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsInput$topLevelDefault",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "topLevelDefault",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_MEMBER_OTHER_TOP_LEVEL_DEFAULT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsInput$otherTopLevelDefault",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "otherTopLevelDefault",
 ,
 );
 static OPERATIONWITHDEFAULTSINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsInput",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_DEFAULTS,
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_CLIENT_OPTIONAL_DEFAULTS,
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_TOP_LEVEL_DEFAULT,
         &OPERATIONWITHDEFAULTSINPUT_MEMBER_OTHER_TOP_LEVEL_DEFAULT,
     ],
-+
+)
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
 .with_original_name("OperationWithDefaultsInput");
 impl OperationWithDefaultsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPERATIONWITHDEFAULTSINPUT_SCHEMA;
-+
+}
 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)?;
-+
+        }
         if let Some(ref val) = self.client_optional_defaults {
             ser.write_struct(&OPERATIONWITHDEFAULTSINPUT_MEMBER_CLIENT_OPTIONAL_DEFAULTS, val)?;
-+
+        }
         if let Some(ref val) = self.top_level_default {
             ser.write_string(&OPERATIONWITHDEFAULTSINPUT_MEMBER_TOP_LEVEL_DEFAULT, val)?;
-+
+        }
         if let Some(ref val) = self.other_top_level_default {
             ser.write_integer(&OPERATIONWITHDEFAULTSINPUT_MEMBER_OTHER_TOP_LEVEL_DEFAULT, *val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl OperationWithDefaultsInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.defaults = Some(crate::types::Defaults::deserialize(deser)?);
-+
+                    }
-+
+                }
                 Some(1) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.client_optional_defaults = Some(crate::types::ClientOptionalDefaults::deserialize(deser)?);
-+
+                    }
-+
+                }
                 Some(2) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.top_level_default = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(3) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.other_top_level_default = Some(deser.read_integer(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 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()
-180
+    }
-181
+}
-182
 /// 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>,
-191
+}
 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
-197
+    }
     #[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
-202
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_defaults(&self) -> &::std::option::Option<crate::types::Defaults> {
         &self.defaults

Pages: 1 2 3 4 5 6 7 8 9 10