Client Test

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/config.rs

@@ -10,10 +69,73 @@

     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-15
+}
 impl Config {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     pub fn builder() -> Builder {
         Builder::default()
-26
+    }
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {

             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-34
+        }
-35
+    }
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-39
+    }
     /// Returns the client protocol used for serialization and deserialization.
     pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
         self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
-+
+    }
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-47
+    }
     /// Return the auth schemes configured on this service config
     pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
         self.runtime_components.auth_schemes()
-51
+    }
-52
     /// Return the auth scheme resolver configured on this service config

↧ Expand context

     pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
         self.runtime_components.auth_scheme_option_resolver()
-56
+    }
     /// Returns the configured auth scheme preference
     pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
         self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
-60
+    }
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-64
+    }
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-68
+    }
-69
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-73
+    }

@@ -105,109 +185,208 @@

↥ Expand context

     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-111
+}
 impl ::std::default::Default for Builder {
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-119
+        }
-120
+    }
-121
+}
 impl Builder {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>

     ///
     pub fn new() -> Self {
         Self::default()
-132
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     #[allow(unused)]
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         let mut builder = Self::new();
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
             builder.set_protocol(::std::option::Option::Some(protocol));
-+
+        }
         builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         builder
-147
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-153
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-162
+    }
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
             protocol,
         )));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         self.config.store_or_unset(protocol);
         self
-+
+    }
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use query_compat_test::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -1116,1139 +1175,1203 @@

↥ Expand context

-1139
+    }
     /// Builds a [`Config`].
     #[allow(unused_mut)]
     pub fn build(mut self) -> Config {
         let mut layer = self.config;
         if self.runtime_components.time_source().is_none() {
             self.runtime_components
                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1147
+        }
         Config {
             config: crate::config::Layer::from(layer.clone())
                 .with_name("query_compat_test::config::Config")
                 .freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
-1156
+        }
-1157
+    }
-1158
+}

 #[derive(::std::fmt::Debug)]
 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1163
+}
-1164
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("QueryCompatService");
             if _service_config.protocol().is_none() {
                 cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0("QueryCompatService"),
                 ));
-+
+            }
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
             use crate::config::auth::ResolveAuthScheme;
             crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());

↧ Expand context

         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-1186
+    }
-1187
+}
-1188
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-1192
+    }
-1193
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
-1196
+    }
-1197
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1203
+    }

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/lib.rs

@@ -94,94 +130,128 @@

↥ Expand context

 ///     .send()
 ///     .await;
 /// ```
 ///
 /// The underlying HTTP requests that get made by this can be modified with the `customize_operation`
 /// function on the fluent builder. See the [`customize`](crate::client::customize) module for more
 /// information.
 pub mod client;
-102
 /// Configuration for the service.
 pub mod config;
-105
 /// Common errors and error handling utilities.
 pub mod error;
-108
 mod error_meta;
-110
 /// Information about this crate.
 pub mod meta;
-113

 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-116
 /// All operations that this crate can perform.
 pub mod operation;
-119
 pub(crate) mod protocol_serde;
-121
 mod sdk_feature_tracker;
-123
 mod serialization_settings;
--
 mod aws_query_compatible_errors;
-125
 mod json_errors;
-127
 pub use client::Client;

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/operation/operation.rs

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

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

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| err.downcast::<crate::operation::operation::OperationError>().expect("correct error type"))
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::operation::OperationOutput>()
                 .expect("correct output type"),
-39
+        )
-40
+    }
-41
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::operation::OperationInput,

@@ -104,108 +228,224 @@

↥ Expand context

         ));
-109
         ::std::option::Option::Some(cfg.freeze())
-111
+    }
-112
     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("Operation")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(OperationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::operation::OperationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::operation::OperationError,
             >::new());
-127

         ::std::borrow::Cow::Owned(rcb)
-129
+    }
-130
+}
-131
 #[derive(Debug)]
 struct OperationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-151
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_operation::de_operation_http_error(status, headers, body)
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(crate::operation::operation::OperationError::generic(generic)),
             ))
         } else {
             crate::protocol_serde::shape_operation::de_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, Operation::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::operation::OperationOutput::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))
-+
+        }
-175
+    }
-176
+}
 #[derive(Debug)]
 struct OperationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OperationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::operation::OperationInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::operation::OperationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::operation::OperationInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "QueryCompatService.Operation",
             );
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::HeaderName::from_static("x-amzn-query-mode"), "true");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_operation::ser_operation_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, Operation::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         request.headers_mut().insert("x-amzn-query-mode", "true");
         return ::std::result::Result::Ok(request);
-195
+    }
-196
+}
 #[derive(Debug)]
 struct OperationEndpointParamsInterceptor;
-199
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationEndpointParamsInterceptor"
-203
+    }
-204

↧ 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::<OperationInput>()
             .ok_or("failed to downcast to OperationInput")?;
-219
         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/query-compat-test/rust-client-codegen/src/operation/operation/_operation_input.rs

@@ -23,23 +108,119 @@

↥ Expand context

         "aws.protocoltests.misc.synthetic",
         "OperationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
 ,
 );
 static OPERATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     OPERATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&OPERATIONINPUT_MEMBER_MESSAGE],
 );
 impl OperationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OPERATIONINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationInput {
     #[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.message {
             ser.write_string(&OPERATIONINPUT_MEMBER_MESSAGE, val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl OperationInput {
     /// 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(&OPERATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&OPERATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl OperationInput {
     /// 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 OperationInput {
     /// Creates a new builder-style object to manufacture [`OperationInput`](crate::operation::operation::OperationInput).
     pub fn builder() -> crate::operation::operation::builders::OperationInputBuilder {
         crate::operation::operation::builders::OperationInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`OperationInput`](crate::operation::operation::OperationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationInputBuilder {
     pub(crate) message: ::std::option::Option<::std::string::String>,
-102
+}
 impl OperationInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.message = ::std::option::Option::Some(input.into());
         self
-108
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.message = input;
         self
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_message(&self) -> &::std::option::Option<::std::string::String> {
         &self.message
-117
+    }
     /// Consumes the builder and constructs a [`OperationInput`](crate::operation::operation::OperationInput).
     pub fn build(self) -> ::std::result::Result<crate::operation::operation::OperationInput, ::aws_smithy_types::error::operation::BuildError> {

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/operation/operation/_operation_output.rs

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

↥ Expand context

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

↧ Expand context

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

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

@@ -1,1 +41,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
--
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
--
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
--
+}
--
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut builder = crate::json_errors::parse_error_metadata(response_body, response_headers)?;
     if let Some((error_code, error_type)) = crate::aws_query_compatible_errors::parse_aws_query_compatible_error(response_headers) {
         builder = builder.code(error_code);
         builder = builder.custom("type", error_type);
-11
+    }
     Ok(builder)
-13
+}
--
 pub(crate) mod shape_operation;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_operation_input;

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/protocol_serde/shape_operation.rs

@@ -1,0 +73,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_operation_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::operation::OperationOutput, crate::operation::operation::OperationError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::operation::OperationError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::operation::OperationError::generic(generic))
--
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_operation_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::operation::OperationOutput, crate::operation::operation::OperationError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::operation::builders::OperationOutputBuilder::default();
         output = crate::protocol_serde::shape_operation::de_operation(_response_body, output)
             .map_err(crate::operation::operation::OperationError::unhandled)?;
         output.build()
     })
--
+}
--
 pub fn ser_operation_input(
     input: &crate::operation::operation::OperationInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_operation_input::ser_operation_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
--
+}
--
 pub(crate) fn de_operation(
     _value: &[u8],
     mut builder: crate::operation::operation::builders::OperationOutputBuilder,
 ) -> ::std::result::Result<crate::operation::operation::builders::OperationOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/protocol_serde/shape_operation_input.rs

@@ -1,0 +10,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_operation_input_input(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::operation::operation::OperationInput,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.message {
         object.key("message").string(var_1.as_str());
--
+    }
     Ok(())
--
+}

tmp-codegen-diff/codegen-client-test/query-compat-test/rust-client-codegen/src/serialization_settings.rs

@@ -1,0 +89,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
--
 #![allow(dead_code)]
--
 use aws_smithy_http::header::set_request_header_if_absent;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
--
 /// Configuration for how default protocol headers are serialized
 #[derive(Clone, Debug, Default)]
 pub(crate) struct HeaderSerializationSettings {
     omit_default_content_length: bool,
     omit_default_content_type: bool,
--
+}
--
 impl HeaderSerializationSettings {
     /// Creates new [`HeaderSerializationSettings`]
     pub(crate) fn new() -> Self {
         Default::default()
--
+    }
--
     /// Omit the default `Content-Length` header during serialization
     pub(crate) fn omit_default_content_length(self) -> Self {
         Self {
             omit_default_content_length: true,
             ..self
--
+        }
--
+    }
--
     /// Omit the default `Content-Type` header during serialization
     pub(crate) fn omit_default_content_type(self) -> Self {
         Self {
             omit_default_content_type: true,
             ..self
--
+        }
--
+    }
--
     /// Returns true if the given default header name should be serialized
     fn include_header(&self, header: &HeaderName) -> bool {
         (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
--
+    }
--
     /// Sets a default header on the given request builder if it should be serialized
     pub(crate) fn set_default_header(
         &self,
         mut request: http_1x::request::Builder,
         header_name: HeaderName,
         value: &str,
     ) -> http_1x::request::Builder {
         if self.include_header(&header_name) {
             request = set_request_header_if_absent(request, header_name, value);
--
+        }
         request
--
+    }
--
+}
--
 impl Storable for HeaderSerializationSettings {
     type Storer = StoreReplace<Self>;
--
+}
--
 #[cfg(test)]
 mod tests {
     use super::*;
--
     #[test]
     fn test_include_header() {
         let settings = HeaderSerializationSettings::default();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
--
         let settings = HeaderSerializationSettings::default().omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
--
         let settings = HeaderSerializationSettings::default().omit_default_content_type();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
--
         let settings = HeaderSerializationSettings::default()
             .omit_default_content_type()
             .omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
--
+    }
--
+}

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

@@ -10,10 +69,73 @@

↥ Expand context

     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-15
+}
 impl Config {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     pub fn builder() -> Builder {
         Builder::default()
-26
+    }
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {

             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-34
+        }
-35
+    }
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-39
+    }
     /// Returns the client protocol used for serialization and deserialization.
     pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
         self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
-+
+    }
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-47
+    }
     /// Return the auth schemes configured on this service config
     pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
         self.runtime_components.auth_schemes()
-51
+    }
-52
     /// Return the auth scheme resolver configured on this service config

↧ Expand context

     pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
         self.runtime_components.auth_scheme_option_resolver()
-56
+    }
     /// Returns the configured auth scheme preference
     pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
         self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
-60
+    }
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-64
+    }
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-68
+    }
-69
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-73
+    }

@@ -105,109 +201,224 @@

↥ Expand context

     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-111
+}
 impl ::std::default::Default for Builder {
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-119
+        }
-120
+    }
-121
+}
 impl Builder {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>

     ///
     pub fn new() -> Self {
         Self::default()
-132
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     #[allow(unused)]
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         let mut builder = Self::new();
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
             builder.set_protocol(::std::option::Option::Some(protocol));
-+
+        }
         builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         builder
-147
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-153
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-162
+    }
     /// Sets the idempotency token provider to use for service calls that require tokens.
     pub fn idempotency_token_provider(
         mut self,
         idempotency_token_provider: impl ::std::convert::Into<crate::idempotency_token::IdempotencyTokenProvider>,
     ) -> Self {
         self.set_idempotency_token_provider(::std::option::Option::Some(idempotency_token_provider.into()));
         self
-170
+    }
     /// Sets the idempotency token provider to use for service calls that require tokens.
     pub fn set_idempotency_token_provider(
         &mut self,
         idempotency_token_provider: ::std::option::Option<crate::idempotency_token::IdempotencyTokenProvider>,
     ) -> &mut Self {
         self.config.store_or_unset(idempotency_token_provider);
         self
-178
+    }
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
             protocol,
         )));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         self.config.store_or_unset(protocol);
         self
-+
+    }
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use rest_json::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -1132,1155 +1191,1219 @@

↥ Expand context

         self
-1156
+    }
     /// Builds a [`Config`].
     #[allow(unused_mut)]
     pub fn build(mut self) -> Config {
         let mut layer = self.config;
         if self.runtime_components.time_source().is_none() {
             self.runtime_components
                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1164
+        }
         Config {
             config: crate::config::Layer::from(layer.clone()).with_name("rest_json::config::Config").freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
-1171
+        }
-1172
+    }
-1173
+}
 #[derive(::std::fmt::Debug)]

 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1178
+}
-1179
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RestJson");
             cfg.store_put(crate::idempotency_token::default_provider());
             if _service_config.protocol().is_none() {
                 cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
-+
+            }
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
             use crate::config::auth::ResolveAuthScheme;
             crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());

↧ Expand context

         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-1202
+    }
-1203
+}
-1204
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-1208
+    }
-1209
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
-1212
+    }
-1213
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1219
+    }

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

@@ -109,109 +145,143 @@

↥ Expand context

 mod error_meta;
-110
 /// Information about this crate.
 pub mod meta;
-113
 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-116
 /// Data structures used by operation inputs/outputs.
 pub mod types;
-119
 pub(crate) mod client_http_checksum_required;
-121
 pub(crate) mod client_idempotency_token;
-123
 mod client_request_compression;
-125
 mod event_receiver;
-127
 mod event_stream_serde;

-129
 mod idempotency_token;
-131
 /// All operations that this crate can perform.
 pub mod operation;
-134
 pub(crate) mod protocol_serde;
-136
 mod sdk_feature_tracker;
-138
 mod serialization_settings;
 mod json_errors;
-140
 mod serde_util;
-142
 mod json_errors;
--
 pub use client::Client;

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

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

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

@@ -113,117 +393,403 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct AllQueryStringTypesResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AllQueryStringTypesResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-160
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_http_error(status, headers, body)
             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::all_query_string_types::AllQueryStringTypesError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_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, AllQueryStringTypes::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::all_query_string_types::AllQueryStringTypesOutput::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 AllQueryStringTypesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for AllQueryStringTypesRequestSerializer {
     #[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::all_query_string_types::AllQueryStringTypesInput>()
             .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::all_query_string_types::AllQueryStringTypesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/AllQueryStringTypesInput").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::all_query_string_types::AllQueryStringTypesInput,
                 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 = [
                     "String",
                     "StringList",
                     "StringSet",
                     "Byte",
                     "Short",
                     "Integer",
                     "IntegerList",
                     "IntegerSet",
                     "Long",
                     "Float",
                     "Double",
                     "DoubleList",
                     "Boolean",
                     "BooleanList",
                     "Timestamp",
                     "TimestampList",
                     "Enum",
                     "EnumList",
                     "IntegerEnum",
                     "IntegerEnumList",
                 ];
                 if let ::std::option::Option::Some(inner_1) = &_input.query_params_map_of_string_list {
         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, AllQueryStringTypes::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-209
+            {
                         for (k, v) in inner_1 {
                             for inner_2 in v {
                                 if !protected_params.contains(&k.as_str()) {
                                     query.push_kv(&::aws_smithy_http::query::fmt_string(k), &::aws_smithy_http::query::fmt_string(inner_2));
                 let mut uri = "/AllQueryStringTypesInput".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.query_string {
                     query_params.push(("String".to_string(), val.to_string()));
-214
+                }
                 if let Some(ref val) = input.query_string_list {
                     for item in val {
                         query_params.push(("StringList".to_string(), item.to_string()));
-218
+                    }
-219
+                }
                 if let Some(ref val) = input.query_string_set {
                     for item in val {
                         query_params.push(("StringSet".to_string(), item.to_string()));
-223
+                    }
-224
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.query_string {
--
+                    {
                         query.push_kv("String", &::aws_smithy_http::query::fmt_string(inner_3));
                 if let Some(ref val) = input.query_byte {
                     query_params.push(("Byte".to_string(), val.to_string()));
-227
+                }
                 if let Some(ref val) = input.query_short {
                     query_params.push(("Short".to_string(), val.to_string()));
-230
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.query_string_list {
--
+                    {
                         for inner_5 in inner_4 {
                             query.push_kv("StringList", &::aws_smithy_http::query::fmt_string(inner_5));
                 if let Some(ref val) = input.query_integer {
                     query_params.push(("Integer".to_string(), val.to_string()));
-233
+                }
                 if let Some(ref val) = input.query_integer_list {
                     for item in val {
                         query_params.push(("IntegerList".to_string(), item.to_string()));
-237
+                    }
-238
+                }
                 if let ::std::option::Option::Some(inner_6) = &_input.query_string_set {
--
+                    {
                         for inner_7 in inner_6 {
                             query.push_kv("StringSet", &::aws_smithy_http::query::fmt_string(inner_7));
                 if let Some(ref val) = input.query_integer_set {
                     for item in val {
                         query_params.push(("IntegerSet".to_string(), item.to_string()));
-242
+                    }
-243
+                }
                 if let Some(ref val) = input.query_long {
                     query_params.push(("Long".to_string(), val.to_string()));
-246
+                }
                 if let ::std::option::Option::Some(inner_8) = &_input.query_byte {
--
+                    {
                         query.push_kv("Byte", ::aws_smithy_types::primitive::Encoder::from(*inner_8).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_9) = &_input.query_short {
--
+                    {
                         query.push_kv("Short", ::aws_smithy_types::primitive::Encoder::from(*inner_9).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_10) = &_input.query_integer {
--
+                    {
                         query.push_kv("Integer", ::aws_smithy_types::primitive::Encoder::from(*inner_10).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_11) = &_input.query_integer_list {
--
+                    {
                         for inner_12 in inner_11 {
                             query.push_kv("IntegerList", ::aws_smithy_types::primitive::Encoder::from(*inner_12).encode());
                 if let Some(ref val) = input.query_float {
                     query_params.push(("Float".to_string(), {
                         let s = val.to_string();
                         match s.as_str() {
                             "inf" => "Infinity".to_string(),
                             "-inf" => "-Infinity".to_string(),
                             _ => s,
-254
+                        }
                     }));
-256
+                }
                 if let Some(ref val) = input.query_double {
                     query_params.push(("Double".to_string(), {
                         let s = val.to_string();
                         match s.as_str() {
                             "inf" => "Infinity".to_string(),
                             "-inf" => "-Infinity".to_string(),
                             _ => s,
-264
+                        }
                 if let ::std::option::Option::Some(inner_13) = &_input.query_integer_set {
--
+                    {
                         for inner_14 in inner_13 {
                             query.push_kv("IntegerSet", ::aws_smithy_types::primitive::Encoder::from(*inner_14).encode());
--
+                        }
                     }));
-266
+                }
                 if let Some(ref val) = input.query_double_list {
                     for item in val {
                         query_params.push(("DoubleList".to_string(), {
                             let s = item.to_string();
                             match s.as_str() {
                                 "inf" => "Infinity".to_string(),
                                 "-inf" => "-Infinity".to_string(),
                                 _ => s,
-275
+                            }
                 if let ::std::option::Option::Some(inner_15) = &_input.query_long {
--
+                    {
                         query.push_kv("Long", ::aws_smithy_types::primitive::Encoder::from(*inner_15).encode());
                         }));
-277
+                    }
-278
+                }
                 if let ::std::option::Option::Some(inner_16) = &_input.query_float {
--
+                    {
                         query.push_kv("Float", ::aws_smithy_types::primitive::Encoder::from(*inner_16).encode());
--
+                    }
                 if let Some(ref val) = input.query_boolean {
                     query_params.push(("Boolean".to_string(), val.to_string()));
-281
+                }
                 if let ::std::option::Option::Some(inner_17) = &_input.query_double {
--
+                    {
                         query.push_kv("Double", ::aws_smithy_types::primitive::Encoder::from(*inner_17).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_18) = &_input.query_double_list {
--
+                    {
                         for inner_19 in inner_18 {
                             query.push_kv("DoubleList", ::aws_smithy_types::primitive::Encoder::from(*inner_19).encode());
                 if let Some(ref val) = input.query_boolean_list {
                     for item in val {
                         query_params.push(("BooleanList".to_string(), item.to_string()));
-285
+                    }
-286
+                }
                 if let Some(ref val) = input.query_timestamp {
                     query_params.push((
                         "Timestamp".to_string(),
                         val.fmt(::aws_smithy_types::date_time::Format::DateTime).expect("valid timestamp"),
                     ));
-292
+                }
                 if let ::std::option::Option::Some(inner_20) = &_input.query_boolean {
--
+                    {
                         query.push_kv("Boolean", ::aws_smithy_types::primitive::Encoder::from(*inner_20).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_21) = &_input.query_boolean_list {
--
+                    {
                         for inner_22 in inner_21 {
                             query.push_kv("BooleanList", ::aws_smithy_types::primitive::Encoder::from(*inner_22).encode());
--
+                        }
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_23) = &_input.query_timestamp {
--
+                    {
                         query.push_kv(
                             "Timestamp",
                             &::aws_smithy_http::query::fmt_timestamp(inner_23, ::aws_smithy_types::date_time::Format::DateTime)?,
                         );
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_24) = &_input.query_timestamp_list {
--
+                    {
                         for inner_25 in inner_24 {
                             query.push_kv(
                                 "TimestampList",
                                 &::aws_smithy_http::query::fmt_timestamp(inner_25, ::aws_smithy_types::date_time::Format::DateTime)?,
                             );
--
+                        }
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_26) = &_input.query_enum {
--
+                    {
                         query.push_kv("Enum", &::aws_smithy_http::query::fmt_string(inner_26.as_str()));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_27) = &_input.query_enum_list {
--
+                    {
                         for inner_28 in inner_27 {
                             query.push_kv("EnumList", &::aws_smithy_http::query::fmt_string(inner_28.as_str()));
--
+                        }
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_29) = &_input.query_integer_enum {
--
+                    {
                         query.push_kv("IntegerEnum", ::aws_smithy_types::primitive::Encoder::from(*inner_29).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_30) = &_input.query_integer_enum_list {
--
+                    {
                         for inner_31 in inner_30 {
                             query.push_kv("IntegerEnumList", ::aws_smithy_types::primitive::Encoder::from(*inner_31).encode());
                 if let Some(ref val) = input.query_timestamp_list {
                     for item in val {
                         query_params.push((
                             "TimestampList".to_string(),
                             item.fmt(::aws_smithy_types::date_time::Format::DateTime).expect("valid timestamp"),
                         ));
-299
+                    }
-300
+                }
                 if let Some(ref val) = input.query_enum {
                     query_params.push(("Enum".to_string(), val.as_str().to_string()));
-+
+                }
                 if let Some(ref val) = input.query_enum_list {
                     for item in val {
                         query_params.push(("EnumList".to_string(), item.as_str().to_string()));
-+
+                    }
-+
+                }
                 if let Some(ref val) = input.query_integer_enum {
                     query_params.push(("IntegerEnum".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref val) = input.query_integer_enum_list {
                     for item in val {
                         query_params.push(("IntegerEnumList".to_string(), item.to_string()));
-+
+                    }
-+
+                }
                 if let Some(ref map) = input.query_params_map_of_string_list {
                     for (k, v) in map {
                         if matches!(
                             k.as_str(),
                             "String"
                                 | "StringList"
                                 | "StringSet"
                                 | "Byte"
                                 | "Short"
                                 | "Integer"
                                 | "IntegerList"
                                 | "IntegerSet"
                                 | "Long"
                                 | "Float"
                                 | "Double"
                                 | "DoubleList"
                                 | "Boolean"
                                 | "BooleanList"
                                 | "Timestamp"
                                 | "TimestampList"
                                 | "Enum"
                                 | "EnumList"
                                 | "IntegerEnum"
                                 | "IntegerEnumList"
                         ) {
                             continue;
-+
+                        }
                         for item in v {
                             query_params.push((k.clone(), item.clone()));
-+
+                        }
-+
+                    }
-+
+                }
                 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("&"));
-362
+                }
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-364
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::all_query_string_types::AllQueryStringTypesInput,
                 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))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-365
         ::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, AllQueryStringTypes::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-374
+    }
-375
+}
 #[derive(Debug)]
 struct AllQueryStringTypesEndpointParamsInterceptor;
-378
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AllQueryStringTypesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "AllQueryStringTypesEndpointParamsInterceptor"
-382
+    }
-383

↧ 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::<AllQueryStringTypesInput>()
             .ok_or("failed to downcast to AllQueryStringTypesInput")?;
-398
         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/all_query_string_types/_all_query_string_types_input.rs

@@ -138,138 +448,449 @@

↥ Expand context

-138
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn query_integer_enum(&self) -> ::std::option::Option<i32> {
         self.query_integer_enum
-142
+    }
     #[allow(missing_docs)] // documentation missing in model
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.query_integer_enum_list.is_none()`.
     pub fn query_integer_enum_list(&self) -> &[i32] {
         self.query_integer_enum_list.as_deref().unwrap_or_default()
-148
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn query_params_map_of_string_list(
         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         self.query_params_map_of_string_list.as_ref()
-154
+    }
-155
+}
 static ALLQUERYSTRINGTYPESINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput",

     "aws.protocoltests.restjson.synthetic",
     "AllQueryStringTypesInput",
 );
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryString",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "query_string",
     "queryString",
 ,
-170
+)
 .with_http_query("String");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryStringList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_string_list",
     "queryStringList",
 ,
-181
+)
 .with_http_query("StringList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryStringSet",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_string_set",
     "queryStringSet",
 ,
-192
+)
 .with_http_query("StringSet");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryByte",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "query_byte",
     "queryByte",
 ,
-203
+)
 .with_http_query("Byte");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryShort",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "query_short",
     "queryShort",
 ,
-214
+)
 .with_http_query("Short");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryInteger",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "query_integer",
     "queryInteger",
 ,
-225
+)
 .with_http_query("Integer");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryIntegerList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_integer_list",
     "queryIntegerList",
 ,
-236
+)
 .with_http_query("IntegerList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryIntegerSet",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_integer_set",
     "queryIntegerSet",
 ,
-247
+)
 .with_http_query("IntegerSet");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryLong",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "query_long",
     "queryLong",
 ,
-258
+)
 .with_http_query("Long");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryFloat",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "query_float",
     "queryFloat",
 ,
-269
+)
 .with_http_query("Float");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryDouble",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "query_double",
     "queryDouble",
 ,
-280
+)
 .with_http_query("Double");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_DOUBLE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryDoubleList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_double_list",
     "queryDoubleList",
 ,
-291
+)
 .with_http_query("DoubleList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryBoolean",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "query_boolean",
     "queryBoolean",
 ,
-302
+)
 .with_http_query("Boolean");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryBooleanList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_boolean_list",
     "queryBooleanList",
 ,
-313
+)
 .with_http_query("BooleanList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryTimestamp",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "query_timestamp",
     "queryTimestamp",
 ,
-324
+)
 .with_http_query("Timestamp");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryTimestampList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_timestamp_list",
     "queryTimestampList",
 ,
-335
+)
 .with_http_query("TimestampList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryEnum",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "query_enum",
     "queryEnum",
 ,
-346
+)
 .with_http_query("Enum");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryEnumList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_enum_list",
     "queryEnumList",
 ,
-357
+)
 .with_http_query("EnumList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryIntegerEnum",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "query_integer_enum",
     "queryIntegerEnum",
 ,
-368
+)
 .with_http_query("IntegerEnum");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryIntegerEnumList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "query_integer_enum_list",
     "queryIntegerEnumList",
 ,
-379
+)
 .with_http_query("IntegerEnumList");
 static ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_PARAMS_MAP_OF_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.restjson.synthetic#AllQueryStringTypesInput$queryParamsMapOfStringList",
         "aws.protocoltests.restjson.synthetic",
         "AllQueryStringTypesInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "query_params_map_of_string_list",
     "queryParamsMapOfStringList",
 ,
-390
+)
 .with_http_query_params();
 static ALLQUERYSTRINGTYPESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ALLQUERYSTRINGTYPESINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING_SET,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_BYTE,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_SHORT,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_SET,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_LONG,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_FLOAT,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_DOUBLE,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_DOUBLE_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_BOOLEAN,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_BOOLEAN_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_TIMESTAMP,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_TIMESTAMP_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_ENUM,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_ENUM_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_ENUM,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_ENUM_LIST,
         &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_PARAMS_MAP_OF_STRING_LIST,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/AllQueryStringTypesInput", None));
 impl AllQueryStringTypesInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALLQUERYSTRINGTYPESINPUT_SCHEMA;
-423
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AllQueryStringTypesInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {

↧ Expand context

         if let Some(ref val) = self.query_string {
             ser.write_string(&ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING, val)?;
-432
+        }
         if let Some(ref val) = self.query_string_list {
             ser.write_list(
                 &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-439
+                    }
                     Ok(())
                 },
             )?;
-443
+        }
         if let Some(ref val) = self.query_string_set {
             ser.write_list(
                 &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_STRING_SET,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;

@@ -537,538 +793,756 @@

↥ Expand context

             ser.write_list(
                 &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-543
+                    }
                     Ok(())
                 },
             )?;
-547
+        }
         if let Some(ref val) = self.query_integer_enum {
             ser.write_integer(&ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_ENUM, *val)?;
-550
+        }
         if let Some(ref val) = self.query_integer_enum_list {
             ser.write_list(
                 &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_INTEGER_ENUM_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_integer(&aws_smithy_schema::prelude::INTEGER, *item)?;
-557
+                    }

                     Ok(())
                 },
             )?;
-561
+        }
         if let Some(ref val) = self.query_params_map_of_string_list {
             ser.write_map(
                 &ALLQUERYSTRINGTYPESINPUT_MEMBER_QUERY_PARAMS_MAP_OF_STRING_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
-+
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-578
+                    }
                     Ok(())
                 },
             )?;
-582
+        }
         Ok(())
-584
+    }
-585
+}
 impl AllQueryStringTypesInput {
     /// 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(&ALLQUERYSTRINGTYPESINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ALLQUERYSTRINGTYPESINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.query_string = Some(deser.read_string(member)?);
-604
+                }
                 Some(1) => {
                     builder.query_string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.query_string_list = Some(deser.read_string_list(member)?);
-607
+                }
                 Some(2) => {
                     builder.query_string_set = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.query_string_set = Some(deser.read_string_list(member)?);
-610
+                }
                 Some(3) => {
                     builder.query_byte = Some(deser.read_byte(member)?);
-613
+                }
                 Some(4) => {
                     builder.query_short = Some(deser.read_short(member)?);
-616
+                }
                 Some(5) => {
                     builder.query_integer = Some(deser.read_integer(member)?);
-619
+                }
                 Some(6) => {
                     builder.query_integer_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.query_integer_list = Some(deser.read_integer_list(member)?);
-622
+                }
                 Some(7) => {
                     builder.query_integer_set = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.query_integer_set = Some(deser.read_integer_list(member)?);
-625
+                }
                 Some(8) => {
                     builder.query_long = Some(deser.read_long(member)?);
-628
+                }
                 Some(9) => {
                     builder.query_float = Some(deser.read_float(member)?);
-631
+                }
                 Some(10) => {
                     builder.query_double = Some(deser.read_double(member)?);
-634
+                }
                 Some(11) => {
                     builder.query_double_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_double(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_double(member)?);
                             Ok(())
                         })?;
                         container
                     });
-644
+                }
                 Some(12) => {
                     builder.query_boolean = Some(deser.read_boolean(member)?);
-647
+                }
                 Some(13) => {
                     builder.query_boolean_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_boolean(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_boolean(member)?);
                             Ok(())
                         })?;
                         container
                     });
-657
+                }
                 Some(14) => {
                     builder.query_timestamp = Some(deser.read_timestamp(member)?);
-660
+                }
                 Some(15) => {
                     builder.query_timestamp_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_timestamp(member)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(deser.read_timestamp(member)?);
                             Ok(())
                         })?;
                         container
                     });
-670
+                }
                 Some(16) => {
                     builder.query_enum = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
-673
+                }
                 Some(17) => {
                     builder.query_enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-683
+                }
                 Some(18) => {
                     builder.query_integer_enum = Some(deser.read_integer(member)?);
-686
+                }
                 Some(19) => {
                     builder.query_integer_enum_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_integer(member)?);
                             Ok(list)
                         })?
                     });
                     builder.query_integer_enum_list = Some(deser.read_integer_list(member)?);
-689
+                }
                 Some(20) => {
                     builder.query_params_map_of_string_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-706
+                }
                 _ => {}
-708
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-714
+    }
-715
+}
 impl AllQueryStringTypesInput {
     /// 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 AllQueryStringTypesInput {
     /// Creates a new builder-style object to manufacture [`AllQueryStringTypesInput`](crate::operation::all_query_string_types::AllQueryStringTypesInput).
     pub fn builder() -> crate::operation::all_query_string_types::builders::AllQueryStringTypesInputBuilder {
         crate::operation::all_query_string_types::builders::AllQueryStringTypesInputBuilder::default()
-731
+    }
-732
+}
-733
 /// A builder for [`AllQueryStringTypesInput`](crate::operation::all_query_string_types::AllQueryStringTypesInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct AllQueryStringTypesInputBuilder {
     pub(crate) query_string: ::std::option::Option<::std::string::String>,
     pub(crate) query_string_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) query_string_set: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) query_byte: ::std::option::Option<i8>,
     pub(crate) query_short: ::std::option::Option<i16>,
     pub(crate) query_integer: ::std::option::Option<i32>,
     pub(crate) query_integer_list: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) query_integer_set: ::std::option::Option<::std::vec::Vec<i32>>,
     pub(crate) query_long: ::std::option::Option<i64>,
     pub(crate) query_float: ::std::option::Option<f32>,
     pub(crate) query_double: ::std::option::Option<f64>,
     pub(crate) query_double_list: ::std::option::Option<::std::vec::Vec<f64>>,
     pub(crate) query_boolean: ::std::option::Option<bool>,
     pub(crate) query_boolean_list: ::std::option::Option<::std::vec::Vec<bool>>,
     pub(crate) query_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) query_timestamp_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
     pub(crate) query_enum: ::std::option::Option<crate::types::FooEnum>,
     pub(crate) query_enum_list: ::std::option::Option<::std::vec::Vec<crate::types::FooEnum>>,
     pub(crate) query_integer_enum: ::std::option::Option<i32>,

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/operation/all_query_string_types/_all_query_string_types_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 AllQueryStringTypesOutput {}
 static ALLQUERYSTRINGTYPESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.restjson.synthetic#AllQueryStringTypesOutput",
     "aws.protocoltests.restjson.synthetic",
     "AllQueryStringTypesOutput",
 );
 static ALLQUERYSTRINGTYPESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(ALLQUERYSTRINGTYPESOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl AllQueryStringTypesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALLQUERYSTRINGTYPESOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AllQueryStringTypesOutput {

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

↧ Expand context

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

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

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

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

@@ -113,119 +249,274 @@

↥ Expand context

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

         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 #[derive(Debug)]
 struct ConstantAndVariableQueryStringResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ConstantAndVariableQueryStringResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-162
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_http_error(status, headers, body)
             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::constant_and_variable_query_string::ConstantAndVariableQueryStringError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_http_response(
                 status, headers, body,
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ConstantAndVariableQueryString::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::constant_and_variable_query_string::ConstantAndVariableQueryStringOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-184
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
             .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 ConstantAndVariableQueryStringRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ConstantAndVariableQueryStringRequestSerializer {
     #[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::constant_and_variable_query_string::ConstantAndVariableQueryStringInput>()
             .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::constant_and_variable_query_string::ConstantAndVariableQueryStringInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/ConstantAndVariableQueryString").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::constant_and_variable_query_string::ConstantAndVariableQueryStringInput,
                 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);
                 query.push_kv("foo", "bar");
                 if let ::std::option::Option::Some(inner_1) = &_input.baz {
--
+                    {
                         query.push_kv("baz", &::aws_smithy_http::query::fmt_string(inner_1));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.maybe_set {
         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, ConstantAndVariableQueryString::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-211
+            {
                         query.push_kv("maybeSet", &::aws_smithy_http::query::fmt_string(inner_2));
--
+                    }
                 let mut uri = "/ConstantAndVariableQueryString?foo=bar".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.baz {
                     query_params.push(("baz".to_string(), val.to_string()));
-+
+                }
                 if let Some(ref val) = input.maybe_set {
                     query_params.push(("maybeSet".to_string(), val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-233
+                }
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-235
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::constant_and_variable_query_string::ConstantAndVariableQueryStringInput,
                 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))
--
+            }
             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, ConstantAndVariableQueryString::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-245
+    }
-246
+}
 #[derive(Debug)]
 struct ConstantAndVariableQueryStringEndpointParamsInterceptor;
-249
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConstantAndVariableQueryStringEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ConstantAndVariableQueryStringEndpointParamsInterceptor"
-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::<ConstantAndVariableQueryStringInput>()
             .ok_or("failed to downcast to ConstantAndVariableQueryStringInput")?;
-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));

Client Test

Files changed: