Client Test

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

@@ -24,24 +107,125 @@

         "HttpPayloadWithStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "nested",
 ,
-29
+)
 .with_http_payload();
 static HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADWITHSTRUCTUREOUTPUT_MEMBER_NESTED],
 );
 impl HttpPayloadWithStructureOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadWithStructureOutput {
     #[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.nested {
             ser.write_struct(&HTTPPAYLOADWITHSTRUCTUREOUTPUT_MEMBER_NESTED, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl HttpPayloadWithStructureOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADWITHSTRUCTUREOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nested = Some(crate::types::NestedPayload::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl HttpPayloadWithStructureOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if !body.is_empty() {
             builder.nested = Some(crate::types::NestedPayload::deserialize(deserializer)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPayloadWithStructureOutput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadWithStructureOutput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput).
     pub fn builder() -> crate::operation::http_payload_with_structure::builders::HttpPayloadWithStructureOutputBuilder {
         crate::operation::http_payload_with_structure::builders::HttpPayloadWithStructureOutputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`HttpPayloadWithStructureOutput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadWithStructureOutputBuilder {
     pub(crate) nested: ::std::option::Option<crate::types::NestedPayload>,
-108
+}
 impl HttpPayloadWithStructureOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(mut self, input: crate::types::NestedPayload) -> Self {
         self.nested = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_nested(mut self, input: ::std::option::Option<crate::types::NestedPayload>) -> Self {
         self.nested = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_nested(&self) -> &::std::option::Option<crate::types::NestedPayload> {
         &self.nested
-123
+    }
     /// Consumes the builder and constructs a [`HttpPayloadWithStructureOutput`](crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput).
     pub fn build(self) -> crate::operation::http_payload_with_structure::HttpPayloadWithStructureOutput {

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

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

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

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

↥ Expand context

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

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

↧ Expand context

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

@@ -310,315 +410,435 @@

↥ Expand context

     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_union_response() {
         let expected_output = crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput::builder()
             .set_nested(::std::option::Option::Some(crate::types::UnionPayload::Greeting("hello".to_owned())))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/json")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{\n    \"greeting\": \"hello\"\n}"))
                 .unwrap(),
-326
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-330
         let op = crate::operation::http_payload_with_union::HttpPayloadWithUnion::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");
-336
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-362
+    }
-363
     /// No payload is sent if the union has no value.
     /// Test ID: RestJsonHttpPayloadWithUnsetUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_unset_union_response() {
         let expected_output = crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Length", "0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-376
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-380
         let op = crate::operation::http_payload_with_union::HttpPayloadWithUnion::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");
-386
         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(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
-412
+    }
-413
+}
-414
 /// Error type for the `HttpPayloadWithUnionError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum HttpPayloadWithUnionError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-422
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-424
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-HttpPayloadWithUnionError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-427
+}
 impl HttpPayloadWithUnionError {
     /// Creates the `HttpPayloadWithUnionError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

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

@@ -5,5 +112,130 @@

↥ Expand context

 pub struct HttpPayloadWithUnionInput {
     #[allow(missing_docs)] // documentation missing in model
     pub nested: ::std::option::Option<crate::types::UnionPayload>,
-8
+}
 impl HttpPayloadWithUnionInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(&self) -> ::std::option::Option<&crate::types::UnionPayload> {
         self.nested.as_ref()
-13
+    }
-14
+}
 static HTTPPAYLOADWITHUNIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPayloadWithUnionInput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPayloadWithUnionInput",
 );
 static HTTPPAYLOADWITHUNIONINPUT_MEMBER_NESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadWithUnionInput$nested",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadWithUnionInput",

     ),
     ::aws_smithy_schema::ShapeType::Union,
     "nested",
 ,
-29
+)
 .with_http_payload();
 static HTTPPAYLOADWITHUNIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADWITHUNIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADWITHUNIONINPUT_MEMBER_NESTED],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/HttpPayloadWithUnion", None));
 impl HttpPayloadWithUnionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADWITHUNIONINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadWithUnionInput {
     #[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.nested {
             ser.write_null(&HTTPPAYLOADWITHUNIONINPUT_MEMBER_NESTED)?;
             ser.write_struct(&HTTPPAYLOADWITHUNIONINPUT_MEMBER_NESTED, val)?;
-49
+        }
         Ok(())
-51
+    }
-52
+}
 impl HttpPayloadWithUnionInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPAYLOADWITHUNIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADWITHUNIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nested = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.nested = Some(crate::types::UnionPayload::deserialize(deser)?);
-71
+                }
                 _ => {}
-73
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-79
+    }
-80
+}
 impl HttpPayloadWithUnionInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if !body.is_empty() {
             builder.nested = Some(crate::types::UnionPayload::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpPayloadWithUnionInput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadWithUnionInput`](crate::operation::http_payload_with_union::HttpPayloadWithUnionInput).
     pub fn builder() -> crate::operation::http_payload_with_union::builders::HttpPayloadWithUnionInputBuilder {
         crate::operation::http_payload_with_union::builders::HttpPayloadWithUnionInputBuilder::default()
-105
+    }
-106
+}
-107
 /// A builder for [`HttpPayloadWithUnionInput`](crate::operation::http_payload_with_union::HttpPayloadWithUnionInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadWithUnionInputBuilder {
     pub(crate) nested: ::std::option::Option<crate::types::UnionPayload>,
-113
+}
 impl HttpPayloadWithUnionInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(mut self, input: crate::types::UnionPayload) -> Self {
         self.nested = ::std::option::Option::Some(input);
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_nested(mut self, input: ::std::option::Option<crate::types::UnionPayload>) -> Self {
         self.nested = input;
         self
-124
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_nested(&self) -> &::std::option::Option<crate::types::UnionPayload> {
         &self.nested
-128
+    }
     /// Consumes the builder and constructs a [`HttpPayloadWithUnionInput`](crate::operation::http_payload_with_union::HttpPayloadWithUnionInput).
     pub fn build(

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

@@ -17,17 +110,125 @@

↥ Expand context

     "aws.protocoltests.restjson.synthetic",
     "HttpPayloadWithUnionOutput",
 );
 static HTTPPAYLOADWITHUNIONOUTPUT_MEMBER_NESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPayloadWithUnionOutput$nested",
         "aws.protocoltests.restjson.synthetic",
         "HttpPayloadWithUnionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "nested",
 ,
-29
+)
 .with_http_payload();
 static HTTPPAYLOADWITHUNIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPAYLOADWITHUNIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPAYLOADWITHUNIONOUTPUT_MEMBER_NESTED],
 );
 impl HttpPayloadWithUnionOutput {

     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPAYLOADWITHUNIONOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPayloadWithUnionOutput {
     #[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.nested {
             ser.write_null(&HTTPPAYLOADWITHUNIONOUTPUT_MEMBER_NESTED)?;
             ser.write_struct(&HTTPPAYLOADWITHUNIONOUTPUT_MEMBER_NESTED, val)?;
-48
+        }
         Ok(())
-50
+    }
-51
+}
 impl HttpPayloadWithUnionOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPAYLOADWITHUNIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPAYLOADWITHUNIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nested = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.nested = Some(crate::types::UnionPayload::deserialize(deser)?);
-70
+                }
                 _ => {}
-72
+            }
             Ok(())
         })?;
         Ok(builder.build())
-76
+    }
-77
+}
 impl HttpPayloadWithUnionOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if !body.is_empty() {
             builder.nested = Some(crate::types::UnionPayload::deserialize(deserializer)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPayloadWithUnionOutput {
     /// Creates a new builder-style object to manufacture [`HttpPayloadWithUnionOutput`](crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput).
     pub fn builder() -> crate::operation::http_payload_with_union::builders::HttpPayloadWithUnionOutputBuilder {
         crate::operation::http_payload_with_union::builders::HttpPayloadWithUnionOutputBuilder::default()
-100
+    }
-101
+}
-102
 /// A builder for [`HttpPayloadWithUnionOutput`](crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPayloadWithUnionOutputBuilder {
     pub(crate) nested: ::std::option::Option<crate::types::UnionPayload>,
-108
+}
 impl HttpPayloadWithUnionOutputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(mut self, input: crate::types::UnionPayload) -> Self {
         self.nested = ::std::option::Option::Some(input);
         self
-114
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_nested(mut self, input: ::std::option::Option<crate::types::UnionPayload>) -> Self {
         self.nested = input;
         self
-119
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_nested(&self) -> &::std::option::Option<crate::types::UnionPayload> {
         &self.nested
-123
+    }
     /// Consumes the builder and constructs a [`HttpPayloadWithUnionOutput`](crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput).
     pub fn build(self) -> crate::operation::http_payload_with_union::HttpPayloadWithUnionOutput {

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

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

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

@@ -110,114 +229,274 @@

↥ Expand context

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

                 crate::operation::http_prefix_headers::HttpPrefixHeadersError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct HttpPrefixHeadersResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpPrefixHeadersResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::http_prefix_headers::HttpPrefixHeadersError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_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, HttpPrefixHeaders::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::http_prefix_headers::HttpPrefixHeadersOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct HttpPrefixHeadersRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpPrefixHeadersRequestSerializer {
     #[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::http_prefix_headers::HttpPrefixHeadersInput>()
             .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::http_prefix_headers::HttpPrefixHeadersInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/HttpPrefixHeaders").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_prefix_headers::HttpPrefixHeadersInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_http_prefix_headers::ser_http_prefix_headers_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, HttpPrefixHeaders::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/HttpPrefixHeaders".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.foo {
                     request.headers_mut().insert("x-foo", val.to_string());
-+
+                }
                 if let Some(ref map) = input.foo_map {
                     for (k, v) in map {
                         request.headers_mut().insert(format!("x-foo-{k}"), v.to_string());
-+
+                    }
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-235
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, HttpPrefixHeaders::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-245
+    }
-246
+}
 #[derive(Debug)]
 struct HttpPrefixHeadersEndpointParamsInterceptor;
-249
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPrefixHeadersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPrefixHeadersEndpointParamsInterceptor"
-253
+    }
-254

↧ Expand context

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

@@ -356,401 +416,471 @@

↥ Expand context

                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("x-foo", "Foo")
                 .header("x-foo-abc", "Abc value")
                 .header("x-foo-def", "Def value")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-412
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-416
         let op = crate::operation::http_prefix_headers::HttpPrefixHeaders::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");
-422
         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(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_prefix_headers::HttpPrefixHeadersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.foo, expected_output.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(parsed.foo_map, expected_output.foo_map, "Unexpected value for `foo_map`");
-449
+    }
-450
+}
-451

↧ Expand context

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

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

@@ -14,14 +151,173 @@

↥ Expand context

         self.foo.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.foo_map.as_ref()
-19
+    }
-20
+}
 static HTTPPREFIXHEADERSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersInput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPrefixHeadersInput",
 );
 static HTTPPREFIXHEADERSINPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersInput$foo",
         "aws.protocoltests.restjson.synthetic",
         "HttpPrefixHeadersInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",

 ,
-35
+)
 .with_http_header("x-foo");
 static HTTPPREFIXHEADERSINPUT_MEMBER_FOO_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersInput$fooMap",
         "aws.protocoltests.restjson.synthetic",
         "HttpPrefixHeadersInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "foo_map",
     "fooMap",
 ,
-46
+)
 .with_http_prefix_headers("x-foo-");
 static HTTPPREFIXHEADERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPREFIXHEADERSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPREFIXHEADERSINPUT_MEMBER_FOO, &HTTPPREFIXHEADERSINPUT_MEMBER_FOO_MAP],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/HttpPrefixHeaders", None));
 impl HttpPrefixHeadersInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPREFIXHEADERSINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPrefixHeadersInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.foo {
             ser.write_string(&HTTPPREFIXHEADERSINPUT_MEMBER_FOO, val)?;
-66
+        }
         if let Some(ref val) = self.foo_map {
             ser.write_map(
                 &HTTPPREFIXHEADERSINPUT_MEMBER_FOO_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-74
+                    }
                     Ok(())
                 },
             )?;
-78
+        }
         Ok(())
-80
+    }
-81
+}
 impl HttpPrefixHeadersInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPREFIXHEADERSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPREFIXHEADERSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-100
+                }
                 Some(1) => {
                     builder.foo_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.foo_map = Some(deser.read_string_string_map(member)?);
-103
+                }
                 _ => {}
-105
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-111
+    }
-112
+}
 impl HttpPrefixHeadersInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-foo") {
             builder.foo = Some(val.to_string());
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("x-foo-") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.foo_map = Some(map);
-+
+            }
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpPrefixHeadersInput {
     /// Creates a new builder-style object to manufacture [`HttpPrefixHeadersInput`](crate::operation::http_prefix_headers::HttpPrefixHeadersInput).
     pub fn builder() -> crate::operation::http_prefix_headers::builders::HttpPrefixHeadersInputBuilder {
         crate::operation::http_prefix_headers::builders::HttpPrefixHeadersInputBuilder::default()
-148
+    }
-149
+}
-150
 /// A builder for [`HttpPrefixHeadersInput`](crate::operation::http_prefix_headers::HttpPrefixHeadersInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

@@ -14,14 +149,168 @@

↥ Expand context

         self.foo.as_deref()
-15
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.foo_map.as_ref()
-19
+    }
-20
+}
 static HTTPPREFIXHEADERSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersOutput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPrefixHeadersOutput",
 );
 static HTTPPREFIXHEADERSOUTPUT_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersOutput$foo",
         "aws.protocoltests.restjson.synthetic",
         "HttpPrefixHeadersOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "foo",

 ,
-35
+)
 .with_http_header("x-foo");
 static HTTPPREFIXHEADERSOUTPUT_MEMBER_FOO_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersOutput$fooMap",
         "aws.protocoltests.restjson.synthetic",
         "HttpPrefixHeadersOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "foo_map",
     "fooMap",
 ,
-46
+)
 .with_http_prefix_headers("x-foo-");
 static HTTPPREFIXHEADERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPREFIXHEADERSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPREFIXHEADERSOUTPUT_MEMBER_FOO, &HTTPPREFIXHEADERSOUTPUT_MEMBER_FOO_MAP],
 );
 impl HttpPrefixHeadersOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPREFIXHEADERSOUTPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPrefixHeadersOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.foo {
             ser.write_string(&HTTPPREFIXHEADERSOUTPUT_MEMBER_FOO, val)?;
-65
+        }
         if let Some(ref val) = self.foo_map {
             ser.write_map(
                 &HTTPPREFIXHEADERSOUTPUT_MEMBER_FOO_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-73
+                    }
                     Ok(())
                 },
             )?;
-77
+        }
         Ok(())
-79
+    }
-80
+}
 impl HttpPrefixHeadersOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPREFIXHEADERSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPREFIXHEADERSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.foo = Some(deser.read_string(member)?);
-99
+                }
                 Some(1) => {
                     builder.foo_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.foo_map = Some(deser.read_string_string_map(member)?);
-102
+                }
                 _ => {}
-104
+            }
             Ok(())
         })?;
         Ok(builder.build())
-108
+    }
-109
+}
 impl HttpPrefixHeadersOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-foo") {
             builder.foo = Some(val.to_string());
-+
+        }
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("x-foo-") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.foo_map = Some(map);
-+
+            }
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPrefixHeadersOutput {
     /// Creates a new builder-style object to manufacture [`HttpPrefixHeadersOutput`](crate::operation::http_prefix_headers::HttpPrefixHeadersOutput).
     pub fn builder() -> crate::operation::http_prefix_headers::builders::HttpPrefixHeadersOutputBuilder {
         crate::operation::http_prefix_headers::builders::HttpPrefixHeadersOutputBuilder::default()
-143
+    }
-144
+}
-145
 /// A builder for [`HttpPrefixHeadersOutput`](crate::operation::http_prefix_headers::HttpPrefixHeadersOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

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

@@ -110,116 +228,241 @@

↥ Expand context

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

                 crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct HttpPrefixHeadersInResponseResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpPrefixHeadersInResponseResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_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, HttpPrefixHeadersInResponse::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct HttpPrefixHeadersInResponseRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpPrefixHeadersInResponseRequestSerializer {
     #[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::http_prefix_headers_in_response::HttpPrefixHeadersInResponseInput>()
             .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::http_prefix_headers_in_response::HttpPrefixHeadersInResponseInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/HttpPrefixHeadersResponse").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseInput,
                 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("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, HttpPrefixHeadersInResponse::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-210
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-212
+    }
-213
+}
 #[derive(Debug)]
 struct HttpPrefixHeadersInResponseEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpPrefixHeadersInResponseEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpPrefixHeadersInResponseEndpointParamsInterceptor"
-220
+    }
-221

↧ Expand context

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

@@ -249,262 +309,332 @@

↥ Expand context

                 ret.insert("hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());
                 ret
             }))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("hello", "Hello")
                 .header("x-foo", "Foo")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(vec![]))
                 .unwrap(),
-273
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-277
         let op = crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponse::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");
-283
         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(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.prefix_headers,
             expected_output.prefix_headers,
             "Unexpected value for `prefix_headers`"
         );

↧ Expand context

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

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

@@ -1,1 +72,86 @@

↥ Expand context

 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct HttpPrefixHeadersInResponseInput {}
 static HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersInResponseInput",
     "aws.protocoltests.restjson.synthetic",
     "HttpPrefixHeadersInResponseInput",
 );
 static HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
     ::aws_smithy_schema::Schema::new_struct(HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
         .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/HttpPrefixHeadersResponse", None));
 impl HttpPrefixHeadersInResponseInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA;
-17
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPrefixHeadersInResponseInput {
     #[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(())
-25
+    }
-26
+}
 impl HttpPrefixHeadersInResponseInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPREFIXHEADERSINRESPONSEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-44
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-50
+    }
-51
+}
 impl HttpPrefixHeadersInResponseInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::builder()
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl HttpPrefixHeadersInResponseInput {
     /// Creates a new builder-style object to manufacture [`HttpPrefixHeadersInResponseInput`](crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseInput).
     pub fn builder() -> crate::operation::http_prefix_headers_in_response::builders::HttpPrefixHeadersInResponseInputBuilder {
         crate::operation::http_prefix_headers_in_response::builders::HttpPrefixHeadersInResponseInputBuilder::default()
-69
+    }
-70
+}
-71
 /// A builder for [`HttpPrefixHeadersInResponseInput`](crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

@@ -1,1 +126,142 @@

↥ 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 HttpPrefixHeadersInResponseOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub prefix_headers: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-8
+}
 impl HttpPrefixHeadersInResponseOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn prefix_headers(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.prefix_headers.as_ref()
-13
+    }
-14
+}
 static HTTPPREFIXHEADERSINRESPONSEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersInResponseOutput",

     "aws.protocoltests.restjson.synthetic",
     "HttpPrefixHeadersInResponseOutput",
 );
 static HTTPPREFIXHEADERSINRESPONSEOUTPUT_MEMBER_PREFIX_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpPrefixHeadersInResponseOutput$prefixHeaders",
         "aws.protocoltests.restjson.synthetic",
         "HttpPrefixHeadersInResponseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "prefix_headers",
     "prefixHeaders",
 ,
-29
+)
 .with_http_prefix_headers("");
 static HTTPPREFIXHEADERSINRESPONSEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPPREFIXHEADERSINRESPONSEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPPREFIXHEADERSINRESPONSEOUTPUT_MEMBER_PREFIX_HEADERS],
 );
 impl HttpPrefixHeadersInResponseOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPPREFIXHEADERSINRESPONSEOUTPUT_SCHEMA;
-39
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpPrefixHeadersInResponseOutput {
     #[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.prefix_headers {
             ser.write_map(
                 &HTTPPREFIXHEADERSINRESPONSEOUTPUT_MEMBER_PREFIX_HEADERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-53
+                    }
                     Ok(())
                 },
             )?;
-57
+        }
         Ok(())
-59
+    }
-60
+}
 impl HttpPrefixHeadersInResponseOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPPREFIXHEADERSINRESPONSEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPPREFIXHEADERSINRESPONSEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.prefix_headers = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.prefix_headers = Some(deser.read_string_string_map(member)?);
-79
+                }
                 _ => {}
-81
+            }
             Ok(())
         })?;
         Ok(builder.build())
-85
+    }
-86
+}
 impl HttpPrefixHeadersInResponseOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
-+
+        {
             let mut map = ::std::collections::HashMap::new();
             for (key, val) in headers.iter() {
                 if let Some(suffix) = key.strip_prefix("") {
                     map.insert(suffix.to_string(), val.to_string());
-+
+                }
-+
+            }
             if !map.is_empty() {
                 builder.prefix_headers = Some(map);
-+
+            }
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl HttpPrefixHeadersInResponseOutput {
     /// Creates a new builder-style object to manufacture [`HttpPrefixHeadersInResponseOutput`](crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseOutput).
     pub fn builder() -> crate::operation::http_prefix_headers_in_response::builders::HttpPrefixHeadersInResponseOutputBuilder {
         crate::operation::http_prefix_headers_in_response::builders::HttpPrefixHeadersInResponseOutputBuilder::default()
-117
+    }
-118
+}
-119
 /// A builder for [`HttpPrefixHeadersInResponseOutput`](crate::operation::http_prefix_headers_in_response::HttpPrefixHeadersInResponseOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpPrefixHeadersInResponseOutputBuilder {
     pub(crate) prefix_headers: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-125
+}
 impl HttpPrefixHeadersInResponseOutputBuilder {
     /// Adds a key-value pair to `prefix_headers`.
     ///
     /// To override the contents of this collection use [`set_prefix_headers`](Self::set_prefix_headers).
     ///
     pub fn prefix_headers(
         mut self,
         k: impl ::std::convert::Into<::std::string::String>,
         v: impl ::std::convert::Into<::std::string::String>,
     ) -> Self {
         let mut hash_map = self.prefix_headers.unwrap_or_default();
         hash_map.insert(k.into(), v.into());
         self.prefix_headers = ::std::option::Option::Some(hash_map);
         self
-140
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_prefix_headers(

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

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

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

@@ -110,116 +246,273 @@

↥ Expand context

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

                 crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct HttpQueryParamsOnlyOperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpQueryParamsOnlyOperationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_query_params_only_operation::de_http_query_params_only_operation_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_query_params_only_operation::de_http_query_params_only_operation_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, HttpQueryParamsOnlyOperation::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct HttpQueryParamsOnlyOperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpQueryParamsOnlyOperationRequestSerializer {
     #[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::http_query_params_only_operation::HttpQueryParamsOnlyOperationInput>()
             .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::http_query_params_only_operation::HttpQueryParamsOnlyOperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/http-query-params-only").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 let protected_params = [];
                 if let ::std::option::Option::Some(inner_1) = &_input.query_map {
--
+                    {
                         for (k, v) in inner_1 {
                             if !protected_params.contains(&k.as_str()) {
                                 query.push_kv(&::aws_smithy_http::query::fmt_string(k), &::aws_smithy_http::query::fmt_string(v));
--
+                            }
--
+                        }
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, HttpQueryParamsOnlyOperation::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/http-query-params-only".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref map) = input.query_map {
                     for (k, v) in map {
                         query_params.push((k.clone(), v.clone()));
-217
+                    }
-218
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-234
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, HttpQueryParamsOnlyOperation::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-244
+    }
-245
+}
 #[derive(Debug)]
 struct HttpQueryParamsOnlyOperationEndpointParamsInterceptor;
-248
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpQueryParamsOnlyOperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpQueryParamsOnlyOperationEndpointParamsInterceptor"
-252
+    }
-253

↧ Expand context

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

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

@@ -1,1 +128,130 @@

↥ 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 HttpQueryParamsOnlyOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub query_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-8
+}
 impl HttpQueryParamsOnlyOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn query_map(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.query_map.as_ref()
-13
+    }
-14
+}
 static HTTPQUERYPARAMSONLYOPERATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#HttpQueryParamsOnlyOperationInput",

     "aws.protocoltests.restjson.synthetic",
     "HttpQueryParamsOnlyOperationInput",
 );
 static HTTPQUERYPARAMSONLYOPERATIONINPUT_MEMBER_QUERY_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpQueryParamsOnlyOperationInput$queryMap",
         "aws.protocoltests.restjson.synthetic",
         "HttpQueryParamsOnlyOperationInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "query_map",
     "queryMap",
 ,
-29
+)
 .with_http_query_params();
 static HTTPQUERYPARAMSONLYOPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPQUERYPARAMSONLYOPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&HTTPQUERYPARAMSONLYOPERATIONINPUT_MEMBER_QUERY_MAP],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/http-query-params-only", None));
 impl HttpQueryParamsOnlyOperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPQUERYPARAMSONLYOPERATIONINPUT_SCHEMA;
-40
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpQueryParamsOnlyOperationInput {
     #[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.query_map {
             ser.write_map(
                 &HTTPQUERYPARAMSONLYOPERATIONINPUT_MEMBER_QUERY_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-54
+                    }
                     Ok(())
                 },
             )?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl HttpQueryParamsOnlyOperationInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPQUERYPARAMSONLYOPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPQUERYPARAMSONLYOPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.query_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.query_map = Some(deser.read_string_string_map(member)?);
-80
+                }
                 _ => {}
-82
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-88
+    }
-89
+}
 impl HttpQueryParamsOnlyOperationInput {
     /// 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 HttpQueryParamsOnlyOperationInput {
     /// Creates a new builder-style object to manufacture [`HttpQueryParamsOnlyOperationInput`](crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationInput).
     pub fn builder() -> crate::operation::http_query_params_only_operation::builders::HttpQueryParamsOnlyOperationInputBuilder {
         crate::operation::http_query_params_only_operation::builders::HttpQueryParamsOnlyOperationInputBuilder::default()
-105
+    }
-106
+}
-107
 /// A builder for [`HttpQueryParamsOnlyOperationInput`](crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpQueryParamsOnlyOperationInputBuilder {
     pub(crate) query_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
-113
+}
 impl HttpQueryParamsOnlyOperationInputBuilder {
     /// Adds a key-value pair to `query_map`.
     ///
     /// To override the contents of this collection use [`set_query_map`](Self::set_query_map).
     ///
     pub fn query_map(mut self, k: impl ::std::convert::Into<::std::string::String>, v: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut hash_map = self.query_map.unwrap_or_default();
         hash_map.insert(k.into(), v.into());
         self.query_map = ::std::option::Option::Some(hash_map);
         self
-124
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_query_map(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>) -> Self {
         self.query_map = input;
         self
-129
+    }
     #[allow(missing_docs)] // documentation missing in model

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

@@ -1,1 +68,79 @@

↥ Expand context

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

     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-27
+    }
-28
+}
 impl HttpQueryParamsOnlyOperationOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPQUERYPARAMSONLYOPERATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPQUERYPARAMSONLYOPERATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-46
+            }
             Ok(())
         })?;
         Ok(builder.build())
-50
+    }
-51
+}
 impl HttpQueryParamsOnlyOperationOutput {
     /// 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 HttpQueryParamsOnlyOperationOutput {
     /// Creates a new builder-style object to manufacture [`HttpQueryParamsOnlyOperationOutput`](crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationOutput).
     pub fn builder() -> crate::operation::http_query_params_only_operation::builders::HttpQueryParamsOnlyOperationOutputBuilder {
         crate::operation::http_query_params_only_operation::builders::HttpQueryParamsOnlyOperationOutputBuilder::default()
-67
+    }
-68
+}
-69
 /// A builder for [`HttpQueryParamsOnlyOperationOutput`](crate::operation::http_query_params_only_operation::HttpQueryParamsOnlyOperationOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

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

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

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

@@ -110,116 +252,294 @@

↥ Expand context

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

                 crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct HttpRequestWithFloatLabelsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for HttpRequestWithFloatLabelsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-154
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_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, HttpRequestWithFloatLabels::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-190
+    }
-191
+}
 #[derive(Debug)]
 struct HttpRequestWithFloatLabelsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for HttpRequestWithFloatLabelsRequestSerializer {
     #[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::http_request_with_float_labels::HttpRequestWithFloatLabelsInput>()
             .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::http_request_with_float_labels::HttpRequestWithFloatLabelsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.float;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("float", "cannot be empty or unset"))?;
                 let mut float_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_1);
                 let float = float_encoder.encode();
                 if float.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "float",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, HttpRequestWithFloatLabels::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/FloatHttpLabels/{float}/{double}".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.float {
                     uri = uri.replace(
                         "{float}",
                         &::aws_smithy_schema::http_protocol::percent_encode(&{
                             let s = val.to_string();
                             match s.as_str() {
                                 "inf" => "Infinity".to_string(),
                                 "-inf" => "-Infinity".to_string(),
                                 _ => s,
-+
+                            }
                         }),
                     );
-226
+                }
                 let input_2 = &_input.double;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("double", "cannot be empty or unset"))?;
                 let mut double_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_2);
                 let double = double_encoder.encode();
                 if double.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "double",
                         "cannot be empty or unset",
                     ));
                 if let Some(ref val) = input.double {
                     uri = uri.replace(
                         "{double}",
                         &::aws_smithy_schema::http_protocol::percent_encode(&{
                             let s = val.to_string();
                             match s.as_str() {
                                 "inf" => "Infinity".to_string(),
                                 "-inf" => "-Infinity".to_string(),
                                 _ => s,
-+
+                            }
                         }),
                     );
-239
+                }
                 ::std::write!(output, "/FloatHttpLabels/{float}/{double}", float = float, double = double).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsInput,
                 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("GET").uri(uri))
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-255
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-256
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, HttpRequestWithFloatLabels::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-265
+    }
-266
+}
 #[derive(Debug)]
 struct HttpRequestWithFloatLabelsEndpointParamsInterceptor;
-269
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for HttpRequestWithFloatLabelsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "HttpRequestWithFloatLabelsEndpointParamsInterceptor"
-273
+    }
-274

↧ Expand context

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

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

@@ -25,25 +135,153 @@

↥ Expand context

 );
 static HTTPREQUESTWITHFLOATLABELSINPUT_MEMBER_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpRequestWithFloatLabelsInput$float",
         "aws.protocoltests.restjson.synthetic",
         "HttpRequestWithFloatLabelsInput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "float",
 ,
-35
+)
 .with_http_label();
 static HTTPREQUESTWITHFLOATLABELSINPUT_MEMBER_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#HttpRequestWithFloatLabelsInput$double",
         "aws.protocoltests.restjson.synthetic",
         "HttpRequestWithFloatLabelsInput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "double",

 ,
-46
+)
 .with_http_label();
 static HTTPREQUESTWITHFLOATLABELSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     HTTPREQUESTWITHFLOATLABELSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &HTTPREQUESTWITHFLOATLABELSINPUT_MEMBER_FLOAT,
         &HTTPREQUESTWITHFLOATLABELSINPUT_MEMBER_DOUBLE,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/FloatHttpLabels/{float}/{double}",
     None,
 ));
 impl HttpRequestWithFloatLabelsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HTTPREQUESTWITHFLOATLABELSINPUT_SCHEMA;
-64
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for HttpRequestWithFloatLabelsInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.float {
             ser.write_float(&HTTPREQUESTWITHFLOATLABELSINPUT_MEMBER_FLOAT, *val)?;
-73
+        }
         if let Some(ref val) = self.double {
             ser.write_double(&HTTPREQUESTWITHFLOATLABELSINPUT_MEMBER_DOUBLE, *val)?;
-76
+        }
         Ok(())
-78
+    }
-79
+}
 impl HttpRequestWithFloatLabelsInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPREQUESTWITHFLOATLABELSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPREQUESTWITHFLOATLABELSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.float = Some(deser.read_float(member)?);
-98
+                }
                 Some(1) => {
                     builder.double = Some(deser.read_double(member)?);
-101
+                }
                 _ => {}
-103
+            }
             Ok(())
         })?;
         builder.float = builder.float.or(Some(0.0f32));
         builder.double = builder.double.or(Some(0.0f64));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-111
+    }
-112
+}
 impl HttpRequestWithFloatLabelsInput {
     /// 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 HttpRequestWithFloatLabelsInput {
     /// Creates a new builder-style object to manufacture [`HttpRequestWithFloatLabelsInput`](crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsInput).
     pub fn builder() -> crate::operation::http_request_with_float_labels::builders::HttpRequestWithFloatLabelsInputBuilder {
         crate::operation::http_request_with_float_labels::builders::HttpRequestWithFloatLabelsInputBuilder::default()
-128
+    }
-129
+}
-130
 /// A builder for [`HttpRequestWithFloatLabelsInput`](crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct HttpRequestWithFloatLabelsInputBuilder {
     pub(crate) float: ::std::option::Option<f32>,
     pub(crate) double: ::std::option::Option<f64>,
-137
+}
 impl HttpRequestWithFloatLabelsInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn float(mut self, input: f32) -> Self {
         self.float = ::std::option::Option::Some(input);
         self
-144
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_float(mut self, input: ::std::option::Option<f32>) -> Self {
         self.float = input;
         self
-149
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_float(&self) -> &::std::option::Option<f32> {
         &self.float
-153
+    }

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

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

↥ Expand context

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

     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-24
+    }
-25
+}
 impl HttpRequestWithFloatLabelsOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&HTTPREQUESTWITHFLOATLABELSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&HTTPREQUESTWITHFLOATLABELSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl HttpRequestWithFloatLabelsOutput {
     /// 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 HttpRequestWithFloatLabelsOutput {
     /// Creates a new builder-style object to manufacture [`HttpRequestWithFloatLabelsOutput`](crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsOutput).
     pub fn builder() -> crate::operation::http_request_with_float_labels::builders::HttpRequestWithFloatLabelsOutputBuilder {
         crate::operation::http_request_with_float_labels::builders::HttpRequestWithFloatLabelsOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`HttpRequestWithFloatLabelsOutput`](crate::operation::http_request_with_float_labels::HttpRequestWithFloatLabelsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

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

Client Test

Files changed: