Server Test

tmp-codegen-diff/codegen-server-test/rest_json_extras-http0x/rust-server-codegen/src/types.rs

@@ -0,1 +0,5 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub use ::aws_smithy_types::date_time::Format as DateTimeFormat;
 pub use ::aws_smithy_types::error::display::DisplayErrorContext;
 pub use ::aws_smithy_types::Blob;
 pub use ::aws_smithy_types::DateTime;

tmp-codegen-diff/codegen-server-test/rest_json_extras-http0x/rust-server-codegen/src/unconstrained.rs

@@ -0,1 +0,40 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 pub(crate) mod map_with_enum_key_unconstrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct MapWithEnumKeyUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-+
     impl From<MapWithEnumKeyUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::map_with_enum_key_constrained::MapWithEnumKeyConstrained,
-+
+        >
-+
+    {
         fn from(value: MapWithEnumKeyUnconstrained) -> Self {
             Self::Unconstrained(value)
-+
+        }
-+
+    }
     impl std::convert::TryFrom<MapWithEnumKeyUnconstrained>
         for crate::constrained::map_with_enum_key_constrained::MapWithEnumKeyConstrained
-+
+    {
         type Error = crate::model::map_with_enum_key::ConstraintViolation;
         fn try_from(value: MapWithEnumKeyUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| {
                     let k: crate::model::StringEnum = k.try_into().map_err(Self::Error::Key)?;
-+
                     Ok((k, v))
                 })
                 .collect();
             let hm = res?;
             Ok(Self(hm))
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/Cargo.toml

@@ -1,1 +62,66 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "rest_json_extras"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]

 codegen-version = "ci"
 protocol = "aws.protocols#restJson1"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["http-1x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.form_urlencoded]
 version = "1"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.http-body-util]
 version = "0.1.3"
 [dependencies.mime]
 version = "0.3"
 [dependencies.nom]
 version = "7"
 [dependencies.percent-encoding]
 version = "2.0.0"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 features = ["http-1x"]
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.hyper]
 version = "0.14.12"
 version = "1"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 rt-tokio = ["aws-smithy-types/rt-tokio"]

↧ Expand context

 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 default = ["rt-tokio", "request-id"]
-65
-66

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/lib.rs

@@ -19,19 +128,131 @@

↥ Expand context

 #![allow(rustdoc::invalid_html_tags)]
 #![forbid(unsafe_code)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //! A REST JSON service that sends JSON requests and responses.
-23
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 //! A fast and customizable Rust implementation of the RestJsonExtras Smithy service.
 //!
 //! # Using RestJsonExtras
 //!
 //! The primary entrypoint is [`RestJsonExtras`]: it satisfies the [`Service<http::Request, Response = http::Response>`](::tower::Service)
 //! trait and therefore can be handed to a [`hyper` server](https://github.com/hyperium/hyper) via [`RestJsonExtras::into_make_service`]
 //! or used in AWS Lambda
 #![cfg_attr(
     feature = "aws-lambda",
     doc = " via [`LambdaHandler`](crate::server::routing::LambdaHandler)."
 )]
 #![cfg_attr(
     not(feature = "aws-lambda"),
     doc = " by enabling the `aws-lambda` feature flag and utilizing the `LambdaHandler`."

 )]
 //! The [`crate::input`], [`crate::output`], and [`crate::error`]
 //! modules provide the types used in each operation.
 //!
 //! ### Running on Hyper
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! # async fn dummy() {
 //! use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig};
 //! use rest_json_extras::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! # let app = RestJsonExtras::builder(
 //! #     RestJsonExtrasConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let server = app.into_make_service();
 //! let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!     .expect("unable to parse the server bind address and port");
 //! ::hyper::Server::bind(&bind).serve(server).await.unwrap();
 //! let listener = TcpListener::bind(bind).await
 //!     .expect("failed to bind TCP listener");
 //! serve(listener, app.into_make_service()).await.unwrap();
 //! # }
 //! ```
 //!
 //! ### Running on Lambda
 //!
 //! ```rust,ignore
 //! use rest_json_extras::server::routing::LambdaHandler;
 //! use rest_json_extras::RestJsonExtras;
 //!
 //! # async fn dummy() {
 //! # let app = RestJsonExtras::builder(
 //! #     RestJsonExtrasConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let handler = LambdaHandler::new(app);
 //! lambda_http::run(handler).await.unwrap();
 //! # }
 //! ```
 //!
 //! # Building the RestJsonExtras
 //!
 //! To construct [`RestJsonExtras`] we use [`RestJsonExtrasBuilder`] returned by [`RestJsonExtras::builder`].
 //!
 //! ## Plugins
 //!
 //! The [`RestJsonExtras::builder`] method, returning [`RestJsonExtrasBuilder`],
 //! accepts a config object on which plugins can be registered.
 //! Plugins allow you to build middleware which is aware of the operation it is being applied to.
 //!
 //! ```rust,no_run
 //! # use rest_json_extras::server::plugin::IdentityPlugin as LoggingPlugin;
 //! # use rest_json_extras::server::plugin::IdentityPlugin as MetricsPlugin;
 //! # use ::hyper::Body;
 //! # use ::hyper::body::Incoming;
 //! use rest_json_extras::server::plugin::HttpPlugins;
 //! use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig, RestJsonExtrasBuilder};
 //!
 //! let http_plugins = HttpPlugins::new()
 //!         .push(LoggingPlugin)
 //!         .push(MetricsPlugin);
 //! let config = RestJsonExtrasConfig::builder().build();
 //! let builder: RestJsonExtrasBuilder<Body, _, _, _> = RestJsonExtras::builder(config);
 //! let builder: RestJsonExtrasBuilder<::hyper::body::Incoming, _, _, _> = RestJsonExtras::builder(config);
 //! ```
 //!
 //! Check out [`crate::server::plugin`] to learn more about plugins.
 //!
 //! ## Handlers
 //!
 //! [`RestJsonExtrasBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.
 //! We call these async functions **handlers**. This is where your application business logic lives.
 //!
 //! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

↧ Expand context

 //!
 //! * A `Result<Output, Error>` if your operation has modeled errors, or
 //! * An `Output` otherwise.
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! async fn infallible_handler(input: Input) -> Output { todo!() }
 //!
 //! async fn fallible_handler(input: Input) -> Result<Output, Error> { todo!() }
 //! ```
 //!
 //! Handlers can accept up to 8 extractors:
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! # struct State;

@@ -135,138 +283,290 @@

↥ Expand context

 //!
 //! async fn handler_with_one_extractor(input: Input, ext: Extension<State>) -> Output {
 //!     todo!()
 //! }
 //!
 //! async fn handler_with_two_extractors(
 //!     input: Input,
 //!     ext0: Extension<State>,
 //!     ext1: ConnectInfo<SocketAddr>,
 //! ) -> Output {
 //!     todo!()
 //! }
 //! ```
 //!
 //! See the [`operation module`](crate::operation) for information on precisely what constitutes a handler.
 //!
 //! ## Build
 //!
 //! You can convert [`RestJsonExtrasBuilder`] into [`RestJsonExtras`] using either [`RestJsonExtrasBuilder::build`] or [`RestJsonExtrasBuilder::build_unchecked`].
 //!

 //! [`RestJsonExtrasBuilder::build`] requires you to provide a handler for every single operation in your Smithy model. It will return an error if that is not the case.
 //!
 //! [`RestJsonExtrasBuilder::build_unchecked`], instead, does not require exhaustiveness. The server will automatically return 500 Internal Server Error to all requests for operations that do not have a registered handler.
 //! [`RestJsonExtrasBuilder::build_unchecked`] is particularly useful if you are deploying your Smithy service as a collection of Lambda functions, where each Lambda is only responsible for a subset of the operations in the Smithy service (or even a single one!).
 //!
 //! # Example
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig};
 //! use rest_json_extras::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = RestJsonExtrasConfig::builder().build();
 //!    let app = RestJsonExtras::builder(config)
 //!        .case_insensitive_error_operation(case_insensitive_error_operation)
 //!        .empty_struct_with_content_on_wire_op(empty_struct_with_content_on_wire_op)
 //!        .enum_query(enum_query)
 //!        .escaped_string_values(escaped_string_values)
 //!        .http_query_params_only_operation(http_query_params_only_operation)
 //!        .map_with_enum_key_op(map_with_enum_key_op)
 //!        .null_in_non_sparse(null_in_non_sparse)
 //!        .primitive_int_header(primitive_int_header)
 //!        .primitive_int_op(primitive_int_op)
 //!        .query_precedence(query_precedence)
 //!        .status_response(status_response)
 //!        .string_payload(string_payload)
 //!        .build()
 //!        .expect("failed to build an instance of RestJsonExtras");
 //!
 //!    let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!        .expect("unable to parse the server bind address and port");
 //!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());
 //!    let listener = TcpListener::bind(bind).await
 //!        .expect("failed to bind TCP listener");
 //!    # let server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!    if let Err(err) = serve(listener, app.into_make_service()).await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use rest_json_extras::{input, output, error};
 //!
 //! async fn case_insensitive_error_operation(input: input::CaseInsensitiveErrorOperationInput) -> Result<output::CaseInsensitiveErrorOperationOutput, error::CaseInsensitiveErrorOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn empty_struct_with_content_on_wire_op(input: input::EmptyStructWithContentOnWireOpInput) -> Result<output::EmptyStructWithContentOnWireOpOutput, error::EmptyStructWithContentOnWireOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn enum_query(input: input::EnumQueryInput) -> Result<output::EnumQueryOutput, error::EnumQueryError> {
 //!     todo!()
 //! }
 //!
 //! async fn escaped_string_values(input: input::EscapedStringValuesInput) -> Result<output::EscapedStringValuesOutput, error::EscapedStringValuesError> {
 //!     todo!()
 //! }
 //!
 //! async fn http_query_params_only_operation(input: input::HttpQueryParamsOnlyOperationInput) -> Result<output::HttpQueryParamsOnlyOperationOutput, error::HttpQueryParamsOnlyOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn map_with_enum_key_op(input: input::MapWithEnumKeyOpInput) -> Result<output::MapWithEnumKeyOpOutput, error::MapWithEnumKeyOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn null_in_non_sparse(input: input::NullInNonSparseInput) -> Result<output::NullInNonSparseOutput, error::NullInNonSparseError> {
 //!     todo!()
 //! }
 //!
 //! async fn primitive_int_header(input: input::PrimitiveIntHeaderInput) -> Result<output::PrimitiveIntHeaderOutput, error::PrimitiveIntHeaderError> {
 //!     todo!()
 //! }
 //!
 //! async fn primitive_int_op(input: input::PrimitiveIntOpInput) -> Result<output::PrimitiveIntOpOutput, error::PrimitiveIntOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn query_precedence(input: input::QueryPrecedenceInput) -> Result<output::QueryPrecedenceOutput, error::QueryPrecedenceError> {
 //!     todo!()
 //! }
 //!
 //! async fn status_response(input: input::StatusResponseInput) -> Result<output::StatusResponseOutput, error::StatusResponseError> {
 //!     todo!()
 //! }
 //!
 //! async fn string_payload(input: input::StringPayloadInput) -> Result<output::StringPayloadOutput, error::StringPayloadError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!
 //! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve
 //! [`serve`]: crate::serve
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html
 //! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html
 //! [operations]: https://smithy.io/2.0/spec/service-types.html#operation
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html
 pub use crate::server::serve::serve;
 pub use crate::service::{
     MissingOperationsError, RestJsonExtras, RestJsonExtrasBuilder, RestJsonExtrasConfig,
     RestJsonExtrasConfigBuilder,
 };
-265
 /// Contains the types that are re-exported from the `aws-smithy-http-server` crate.
 pub mod server {
     // Re-export all types from the `aws-smithy-http-server` crate.
     pub use ::aws_smithy_http_server::*;
-270
+}

↧ Expand context

-271
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-274
 /// Constrained types for constrained shapes.
 mod constrained;
-277
 /// All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-280
 /// Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-283
 /// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.
 pub mod model;
-286
 /// All operations that this crate can perform.
 pub mod operation;
-289
 /// A collection of types representing each operation defined in the service closure.

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/operation.rs

@@ -11,11 +71,71 @@

↥ Expand context

     type Output = Result<
         crate::input::HttpQueryParamsOnlyOperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-15
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-22
+    }
-23
+}
-24
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpQueryParamsOnlyOperationInput
 where

     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-37
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpQueryParamsOnlyOperationInputFuture;
-40
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-48
+            }
             crate::protocol_serde::shape_http_query_params_only_operation::de_http_query_params_only_operation_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-58
+                )
             },
         );
         HttpQueryParamsOnlyOperationInputFuture {
             inner: Box::pin(fut),
-63
+        }
-64
+    }
-65
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpQueryParamsOnlyOperationOutput
-70
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -84,84 +202,206 @@

↥ Expand context

     > for crate::error::HttpQueryParamsOnlyOperationError
-85
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-95
+            }
-96
+        }
-97
+    }
-98
+}
-99
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_query_params_only_operation_test {
-103

     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::HttpQueryParamsOnlyOperationError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-134
+    }
-135
+}
-136
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-142
+    }
-143
+}
-144
 impl std::future::Future for QueryPrecedenceInputFuture {
     type Output = Result<
         crate::input::QueryPrecedenceInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-150
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-157
+    }
-158
+}
-159
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-168
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-172
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
-175
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-183
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-193
+                )
             },
         );
         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-198
+        }
-199
+    }
-200
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
-205
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -216,220 +391,405 @@

↥ Expand context

         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryPrecedenceError
-222
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_error(&self)
-225
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-231
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-235
+            }
-236
+        }
-237
+    }
-238
+}
-239

 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod query_precedence_test {
-243
     /// Servers put all query params in map
     /// Test ID: RestJsonServersPutAllQueryParamsInMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_servers_put_all_query_params_in_map_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
         let mut http_request = ::http_1x::Request::builder()
             .uri("/Precedence")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
             .body(::aws_smithy_http_server::body::boxed(
                 ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                     &::aws_smithy_protocol_test::decode_body_data(
                         "".as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                     ),
                 )),
             ))
             .unwrap();
         *http_request.uri_mut() = "/Precedence?bar=named&qux=fromMap".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
         let service = crate::service::RestJsonExtras::builder::<
             ::aws_smithy_http_server::body::BoxBody,
             _,
             _,
             _,
         >(config)
         .query_precedence(move |input: crate::input::QueryPrecedenceInput| {
             let sender = sender.clone();
             async move {
                 let result = {
                     let expected = crate::input::QueryPrecedenceInput {
                         foo: ::std::option::Option::Some("named".to_owned()),
                         baz: ::std::option::Option::Some({
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert("bar".to_owned(), "named".to_owned());
                             ret.insert("qux".to_owned(), "fromMap".to_owned());
                             ret
                         }),
                     };
                     ::pretty_assertions::assert_eq!(input, expected);
                     let output = crate::output::QueryPrecedenceOutput {};
                     Ok(output)
                 };
                 sender.send(()).await.expect("receiver dropped early");
                 result
-291
+            }
         })
         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-301
+    }
-302
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::QueryPrecedenceError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-333
+    }
-334
+}
-335
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EmptyStructWithContentOnWireOpInput`](crate::input::EmptyStructWithContentOnWireOpInput) using modelled bindings.
     pub struct EmptyStructWithContentOnWireOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyStructWithContentOnWireOpInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-341
+    }
-342
+}
-343
 impl std::future::Future for EmptyStructWithContentOnWireOpInputFuture {
     type Output = Result<
         crate::input::EmptyStructWithContentOnWireOpInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-349
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-356
+    }
-357
+}
-358
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyStructWithContentOnWireOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-367
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-371
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyStructWithContentOnWireOpInputFuture;
-374
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-382
+            }
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-392
+                )
             },
         );
         EmptyStructWithContentOnWireOpInputFuture {
             inner: Box::pin(fut),
-397
+        }
-398
+    }
-399
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyStructWithContentOnWireOpOutput
-404
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -404,418 +522,540 @@

↥ Expand context

     > for crate::error::EmptyStructWithContentOnWireOpError
-419
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-429
+            }
-430
+        }
-431
+    }
-432
+}
-433
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_struct_with_content_on_wire_op_test {
-437

     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::EmptyStructWithContentOnWireOpError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-468
+    }
-469
+}
-470
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`CaseInsensitiveErrorOperationInput`](crate::input::CaseInsensitiveErrorOperationInput) using modelled bindings.
     pub struct CaseInsensitiveErrorOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::CaseInsensitiveErrorOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-476
+    }
-477
+}
-478
 impl std::future::Future for CaseInsensitiveErrorOperationInputFuture {
     type Output = Result<
         crate::input::CaseInsensitiveErrorOperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-484
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-491
+    }
-492
+}
-493
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CaseInsensitiveErrorOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-502
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-506
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CaseInsensitiveErrorOperationInputFuture;
-509
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-517
+            }
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-527
+                )
             },
         );
         CaseInsensitiveErrorOperationInputFuture {
             inner: Box::pin(fut),
-532
+        }
-533
+    }
-534
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CaseInsensitiveErrorOperationOutput
-539
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -535,553 +653,675 @@

↥ Expand context

     > for crate::error::CaseInsensitiveErrorOperationError
-554
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-564
+            }
-565
+        }
-566
+    }
-567
+}
-568
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod case_insensitive_error_operation_test {
-572

     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::CaseInsensitiveErrorOperationError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-603
+    }
-604
+}
-605
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullInNonSparseInput`](crate::input::NullInNonSparseInput) using modelled bindings.
     pub struct NullInNonSparseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullInNonSparseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-611
+    }
-612
+}
-613
 impl std::future::Future for NullInNonSparseInputFuture {
     type Output = Result<
         crate::input::NullInNonSparseInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-619
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-626
+    }
-627
+}
-628
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullInNonSparseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-637
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-641
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullInNonSparseInputFuture;
-644
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-652
+            }
             crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(
                 request,
-655
+            )

↧ Expand context

             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-664
+                )
             },
         );
         NullInNonSparseInputFuture {
             inner: Box::pin(fut),
-669
+        }
-670
+    }
-671
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullInNonSparseOutput

@@ -674,696 +792,818 @@

↥ Expand context

             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-703
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-707
+            }
-708
+        }
-709
+    }
-710
+}
-711
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod null_in_non_sparse_test {
-715

     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::NullInNonSparseError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-746
+    }
-747
+}
-748
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput) using modelled bindings.
     pub struct EscapedStringValuesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EscapedStringValuesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-754
+    }
-755
+}
-756
 impl std::future::Future for EscapedStringValuesInputFuture {
     type Output = Result<
         crate::input::EscapedStringValuesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-762
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-769
+    }
-770
+}
-771
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EscapedStringValuesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-780
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-784
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EscapedStringValuesInputFuture;
-787
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-795
+            }
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-805
+                )
             },
         );
         EscapedStringValuesInputFuture {
             inner: Box::pin(fut),
-810
+        }
-811
+    }
-812
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EscapedStringValuesOutput
-817
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -800,826 +1004,1045 @@

↥ Expand context

-826
+    }
-827
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EscapedStringValuesError
-832
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-842
+            }
-843
+        }
-844
+    }
-845
+}

-846
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod escaped_string_values_test {
-850
     /// Test ID: EscapedStringValuesRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn escaped_string_values_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
         let mut http_request = ::http_1x::Request::builder()
             .uri("/escaped-string-values")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}".as_bytes(),
             .body(::aws_smithy_http_server::body::boxed(
                 ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                     &::aws_smithy_protocol_test::decode_body_data(
                         "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}"
                             .as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                     ),
                 )),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
         let service = crate::service::RestJsonExtras::builder::<
             ::aws_smithy_http_server::body::BoxBody,
             _,
             _,
             _,
         >(config)
         .escaped_string_values(move |input: crate::input::EscapedStringValuesInput| {
             let sender = sender.clone();
             async move {
                 let result = {
                     let expected = crate::input::EscapedStringValuesInput {
                         r#enum: ::std::option::Option::Some(
                             "has\"quotes"
                                 .parse::<crate::model::EnumWithEscapedChars>()
                                 .expect("static value validated to member"),
                         ),
                         some_string: ::std::option::Option::Some("test".to_owned()),
                     };
                     ::pretty_assertions::assert_eq!(input, expected);
                     let output = crate::output::EscapedStringValuesOutput {
                         r#enum: ::std::option::Option::None,
                         some_string: ::std::option::Option::None,
                     };
                     Ok(output)
                 };
                 sender.send(()).await.expect("receiver dropped early");
                 result
-900
+            }
         })
         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-910
+    }
     /// Test ID: EscapedStringValuesResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn escaped_string_values_response_response() {
         let output = crate::output::EscapedStringValuesOutput {
             r#enum: ::std::option::Option::Some(
                 "has\"quotes"
                     .parse::<crate::model::EnumWithEscapedChars>()
                     .expect("static value validated to member"),
             ),
             some_string: ::std::option::Option::Some("test".to_owned()),
         };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-941
+    }
-942
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::EscapedStringValuesError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-973
+    }
-974
+}
-975
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PrimitiveIntOpInput`](crate::input::PrimitiveIntOpInput) using modelled bindings.
     pub struct PrimitiveIntOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntOpInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-981
+    }
-982
+}
-983
 impl std::future::Future for PrimitiveIntOpInputFuture {
     type Output = Result<
         crate::input::PrimitiveIntOpInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-989
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-996
+    }
-997
+}
-998
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1007
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1011
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntOpInputFuture;
-1014
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1022
+            }
             crate::protocol_serde::shape_primitive_int_op::de_primitive_int_op_http_request(request)
                 .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1032
+                )
             },
         );
         PrimitiveIntOpInputFuture {
             inner: Box::pin(fut),
-1037
+        }
-1038
+    }
-1039
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntOpOutput
-1044
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -1022,1063 +1140,1185 @@

↥ Expand context

         match crate::protocol_serde::shape_primitive_int_op::ser_primitive_int_op_http_error(&self)
-1064
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-1070
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1074
+            }
-1075
+        }
-1076
+    }
-1077
+}
-1078
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod primitive_int_op_test {
-1082

     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::PrimitiveIntOpError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-1113
+    }
-1114
+}
-1115
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MapWithEnumKeyOpInput`](crate::input::MapWithEnumKeyOpInput) using modelled bindings.
     pub struct MapWithEnumKeyOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MapWithEnumKeyOpInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1121
+    }
-1122
+}
-1123
 impl std::future::Future for MapWithEnumKeyOpInputFuture {
     type Output = Result<
         crate::input::MapWithEnumKeyOpInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1129
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1136
+    }
-1137
+}
-1138
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MapWithEnumKeyOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1147
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1151
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MapWithEnumKeyOpInputFuture;
-1154
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1162
+            }
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_request(
                 request,
-1165
+            )

↧ Expand context

             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1174
+                )
             },
         );
         MapWithEnumKeyOpInputFuture {
             inner: Box::pin(fut),
-1179
+        }
-1180
+    }
-1181
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MapWithEnumKeyOpOutput

@@ -1154,1199 +1365,1424 @@

↥ Expand context

         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MapWithEnumKeyOpError
-1201
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-1211
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1215
+            }
-1216
+        }
-1217
+    }
-1218
+}

-1219
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod map_with_enum_key_op_test {
-1223
     /// Test ID: MapWithEnumKeyRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
         let mut http_request = ::http_1x::Request::builder()
             .uri("/map-with-enum-key")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
             .body(::aws_smithy_http_server::body::boxed(
                 ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                     &::aws_smithy_protocol_test::decode_body_data(
                         "{\"map\":{\"enumvalue\":\"something\"}}".as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                     ),
                 )),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
         let service = crate::service::RestJsonExtras::builder::<
             ::aws_smithy_http_server::body::BoxBody,
             _,
             _,
             _,
         >(config)
         .map_with_enum_key_op(move |input: crate::input::MapWithEnumKeyOpInput| {
             let sender = sender.clone();
             async move {
                 let result = {
                     let expected = crate::input::MapWithEnumKeyOpInput {
                         map: ::std::option::Option::Some({
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "enumvalue"
                                     .parse::<crate::model::StringEnum>()
                                     .expect("static value validated to member"),
                                 "something".to_owned(),
                             );
                             ret
                         }),
                     };
                     ::pretty_assertions::assert_eq!(input, expected);
                     let output = crate::output::MapWithEnumKeyOpOutput {
                         map: ::std::option::Option::None,
                     };
                     Ok(output)
                 };
                 sender.send(()).await.expect("receiver dropped early");
                 result
-1275
+            }
         })
         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-1285
+    }
     /// Test ID: MapWithEnumKeyResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_response_response() {
         let output = crate::output::MapWithEnumKeyOpOutput {
             map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue"
                         .parse::<crate::model::StringEnum>()
                         .expect("static value validated to member"),
                     "something".to_owned(),
                 );
                 ret
             }),
         };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{\"map\":{\"enumvalue\":\"something\"}}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-1320
+    }
-1321
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::MapWithEnumKeyOpError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-1352
+    }
-1353
+}
-1354
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StatusResponseInput`](crate::input::StatusResponseInput) using modelled bindings.
     pub struct StatusResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StatusResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1360
+    }
-1361
+}
-1362
 impl std::future::Future for StatusResponseInputFuture {
     type Output = Result<
         crate::input::StatusResponseInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1368
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1375
+    }
-1376
+}
-1377
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StatusResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1386
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1390
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StatusResponseInputFuture;
-1393
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1401
+            }
             crate::protocol_serde::shape_status_response::de_status_response_http_request(request)
                 .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1411
+                )
             },
         );
         StatusResponseInputFuture {
             inner: Box::pin(fut),
-1416
+        }
-1417
+    }
-1418
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StatusResponseOutput
-1423
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -1381,1440 +1499,1562 @@

↥ Expand context

     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-1447
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1451
+            }
-1452
+        }
-1453
+    }
-1454
+}
-1455
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod status_response_test {
-1459

     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::StatusResponseError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-1490
+    }
-1491
+}
-1492
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EnumQueryInput`](crate::input::EnumQueryInput) using modelled bindings.
     pub struct EnumQueryInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EnumQueryInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1498
+    }
-1499
+}
-1500
 impl std::future::Future for EnumQueryInputFuture {
     type Output = Result<
         crate::input::EnumQueryInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1506
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1513
+    }
-1514
+}
-1515
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EnumQueryInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1524
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1528
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EnumQueryInputFuture;
-1531
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1539
+            }
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;

↧ Expand context

         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1548
+                )
             },
         );
         EnumQueryInputFuture {
             inner: Box::pin(fut),
-1553
+        }
-1554
+    }
-1555
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EnumQueryOutput
-1560
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_response(self) {

@@ -1508,1571 +1673,1746 @@

↥ Expand context

 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EnumQueryError
-1575
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-1583
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1587
+            }
-1588
+        }
-1589
+    }
-1590
+}

-1591
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod enum_query_test {
-1595
     /// Test ID: EnumQueryRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn enum_query_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
         let mut http_request = ::http_1x::Request::builder()
             .uri("/foo/enumvalue")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::empty())
             .body(::aws_smithy_http_server::body::boxed(
                 ::http_body_util::Empty::new(),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
         let service = crate::service::RestJsonExtras::builder::<
             ::aws_smithy_http_server::body::BoxBody,
             _,
             _,
             _,
         >(config)
         .enum_query(move |input: crate::input::EnumQueryInput| {
             let sender = sender.clone();
             async move {
                 let result = {
                     let expected = crate::input::EnumQueryInput {
                         r#enum: "enumvalue"
                             .parse::<crate::model::StringEnum>()
                             .expect("static value validated to member"),
                     };
                     ::pretty_assertions::assert_eq!(input, expected);
                     let output = crate::output::EnumQueryOutput {};
                     Ok(output)
                 };
                 sender.send(()).await.expect("receiver dropped early");
                 result
-1632
+            }
         })
         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-1642
+    }
-1643
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::EnumQueryError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-1674
+    }
-1675
+}
-1676
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PrimitiveIntHeaderInput`](crate::input::PrimitiveIntHeaderInput) using modelled bindings.
     pub struct PrimitiveIntHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntHeaderInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1682
+    }
-1683
+}
-1684
 impl std::future::Future for PrimitiveIntHeaderInputFuture {
     type Output = Result<
         crate::input::PrimitiveIntHeaderInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1690
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1697
+    }
-1698
+}
-1699
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1708
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1712
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntHeaderInputFuture;
-1715
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1723
+            }
             crate::protocol_serde::shape_primitive_int_header::de_primitive_int_header_http_request(
                 request,
-1726
+            )

↧ Expand context

             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1735
+                )
             },
         );
         PrimitiveIntHeaderInputFuture {
             inner: Box::pin(fut),
-1740
+        }
-1741
+    }
-1742
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntHeaderOutput

@@ -1690,1763 +1840,1917 @@

↥ Expand context

     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-1772
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1776
+            }
-1777
+        }
-1778
+    }
-1779
+}
-1780
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]

 mod primitive_int_header_test {
-1784
     /// Test ID: DeserPrimitiveHeader
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_primitive_header_response() {
         let output = crate::output::PrimitiveIntHeaderOutput { field: 123 };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("x-field", "123")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-1801
+    }
     /// Test ID: DeserPrimitiveHeaderMissing
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_primitive_header_missing_response() {
         let output = crate::output::PrimitiveIntHeaderOutput { field: 0 };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
-1813
+    }
-1814
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::PrimitiveIntHeaderError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-1845
+    }
-1846
+}
-1847
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StringPayloadInput`](crate::input::StringPayloadInput) using modelled bindings.
     pub struct StringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StringPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1853
+    }
-1854
+}
-1855
 impl std::future::Future for StringPayloadInputFuture {
     type Output = Result<
         crate::input::StringPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1861
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1868
+    }
-1869
+}
-1870
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1879
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1883
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StringPayloadInputFuture;
-1886
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1894
+            }
             crate::protocol_serde::shape_string_payload::de_string_payload_http_request(request)
                 .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1904
+                )
             },
         );
         StringPayloadInputFuture {
             inner: Box::pin(fut),
-1909
+        }
-1910
+    }
-1911
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StringPayloadOutput
-1916
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -1850,1927 +1950,2037 @@

↥ Expand context

 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StringPayloadError
-1931
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-1939
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1943
+            }
-1944
+        }
-1945
+    }
-1946
+}

-1947
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod string_payload_test {
-1951
     /// Test ID: StringPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn string_payload_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
         let mut http_request = ::http_1x::Request::builder()
             .uri("/StringPayload")
             .method("POST")
             .header("Content-Type", "text/plain")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
             .body(::aws_smithy_http_server::body::boxed(
                 ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                     &::aws_smithy_protocol_test::decode_body_data(
                         "rawstring".as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                     ),
                 )),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
         let service = crate::service::RestJsonExtras::builder::<
             ::aws_smithy_http_server::body::BoxBody,
             _,
             _,
             _,
         >(config)
         .string_payload(move |input: crate::input::StringPayloadInput| {
             let sender = sender.clone();
             async move {
                 let result = {
                     let expected = crate::input::StringPayloadInput {
                         payload: ::std::option::Option::Some("rawstring".to_owned()),
                     };
                     ::pretty_assertions::assert_eq!(input, expected);
                     let output = crate::output::StringPayloadOutput {
                         payload: ::std::option::Option::None,
                     };
                     Ok(output)
                 };
                 sender.send(()).await.expect("receiver dropped early");
                 result
-1994
+            }
         })
         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-2004
+    }
-2005
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::StringPayloadError::ExtraError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-2036
+    }
-2037
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_case_insensitive_error_operation.rs

@@ -1,1 +116,116 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_case_insensitive_error_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::CaseInsensitiveErrorOperationInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::case_insensitive_error_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(&headers, None)?;
         input.build()
     })
-25
+}
-26
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_case_insensitive_error_operation_http_response(
     #[allow(unused_variables)] output: crate::output::CaseInsensitiveErrorOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-54
+}
-55
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_case_insensitive_error_operation_http_error(
     error: &crate::error::CaseInsensitiveErrorOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::CaseInsensitiveErrorOperationError::CaseInsensitiveError(output) => {
                 let payload = crate::protocol_serde::shape_case_insensitive_error::ser_case_insensitive_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "CaseInsensitiveError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-88
+            }
             crate::error::CaseInsensitiveErrorOperationError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-113
+            }
-114
+        }
     })
-116
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_empty_struct_with_content_on_wire_op.rs

@@ -1,1 +95,95 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_empty_struct_with_content_on_wire_op_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::EmptyStructWithContentOnWireOpInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input =
             crate::input::empty_struct_with_content_on_wire_op_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(&headers, None)?;
         input.build()
     })
-26
+}
-27
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_empty_struct_with_content_on_wire_op_http_response(
     #[allow(unused_variables)] output: crate::output::EmptyStructWithContentOnWireOpOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op_output::ser_empty_struct_with_content_on_wire_op_output_output_output(&output)?
-47
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-57
+}
-58
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_empty_struct_with_content_on_wire_op_http_error(
     error: &crate::error::EmptyStructWithContentOnWireOpError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::EmptyStructWithContentOnWireOpError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-92
+            }
-93
+        }
     })
-95
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_enum_query.rs

@@ -1,1 +132,132 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_enum_query_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::EnumQueryInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::enum_query_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let input_string = uri.path();
         let (input_string, (_, m1)) =
             ::nom::sequence::tuple::<_, _, ::nom::error::Error<&str>, _>((
                 ::nom::sequence::preceded(
                     ::nom::bytes::complete::tag("/"),
                     ::nom::bytes::complete::tag::<_, _, ::nom::error::Error<&str>>("foo"),
                 ),
                 ::nom::sequence::preceded(
                     ::nom::bytes::complete::tag("/"),
                     ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
                         ::nom::bytes::complete::take_until("/"),
                         ::nom::combinator::rest,
                     )),
                 ),
             ))(input_string)?;
         debug_assert_eq!("", input_string);
         input = input.set_enum(crate::protocol_serde::shape_enum_query_input::de_enum(m1)?);
         input.build()?
     })
-41
+}
-42
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_enum_query_http_response(
     #[allow(unused_variables)] output: crate::output::EnumQueryOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-70
+}
-71
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_enum_query_http_error(
     error: &crate::error::EnumQueryError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::EnumQueryError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-104
+            }
             crate::error::EnumQueryError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-129
+            }
-130
+        }
     })
-132
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_escaped_string_values.rs

@@ -1,1 +149,152 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_escaped_string_values_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::EscapedStringValuesInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::escaped_string_values_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values(
                 bytes.as_ref(),
                 input,
             )?;
-35
+        }
         input.build()?
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_escaped_string_values_http_response(
     #[allow(unused_variables)] output: crate::output::EscapedStringValuesOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_escaped_string_values_output::ser_escaped_string_values_output_output_output(&output)?
-59
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-69
+}
-70
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_escaped_string_values_http_error(
     error: &crate::error::EscapedStringValuesError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::EscapedStringValuesError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-103
+            }
             crate::error::EscapedStringValuesError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-128
+            }
-129
+        }
     })
-131
+}
-132

↧ Expand context

 pub(crate) fn de_escaped_string_values(
     value: &[u8],
     mut builder: crate::input::escaped_string_values_input::Builder,
 ) -> ::std::result::Result<
     crate::input::escaped_string_values_input::Builder,
     ::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() {
                     "enum" => {
                         builder = builder.set_enum(
                             ::aws_smithy_json::deserialize::token::expect_string_or_null(

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_http_query_params_only_operation.rs

@@ -1,1 +103,103 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_http_query_params_only_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::HttpQueryParamsOnlyOperationInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::http_query_params_only_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let query_string = uri.query().unwrap_or("");
         let pairs = ::form_urlencoded::parse(query_string.as_bytes());
         let mut query_params: ::std::collections::HashMap<
             ::std::string::String,
             ::std::string::String,
         > = ::std::collections::HashMap::new();
         for (k, v) in pairs {
             query_params
                 .entry(String::from(k))
                 .or_insert_with(|| String::from(v));
-32
+        }
         input = input.set_query_map(Some(query_params));
         input.build()
     })
-36
+}
-37
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_http_query_params_only_operation_http_response(
     #[allow(unused_variables)] output: crate::output::HttpQueryParamsOnlyOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-65
+}
-66
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_http_query_params_only_operation_http_error(
     error: &crate::error::HttpQueryParamsOnlyOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::HttpQueryParamsOnlyOperationError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-100
+            }
-101
+        }
     })
-103
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_map_with_enum_key_op.rs

@@ -1,1 +149,152 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_map_with_enum_key_op_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::MapWithEnumKeyOpInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::map_with_enum_key_op_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op(
                 bytes.as_ref(),
                 input,
             )?;
-35
+        }
         input.build()?
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_map_with_enum_key_op_http_response(
     #[allow(unused_variables)] output: crate::output::MapWithEnumKeyOpOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_map_with_enum_key_op_output::ser_map_with_enum_key_op_output_output_output(&output)?
-59
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-69
+}
-70
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_map_with_enum_key_op_http_error(
     error: &crate::error::MapWithEnumKeyOpError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::MapWithEnumKeyOpError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-103
+            }
             crate::error::MapWithEnumKeyOpError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-128
+            }
-129
+        }
     })
-131
+}
-132

↧ Expand context

 pub(crate) fn de_map_with_enum_key_op(
     value: &[u8],
     mut builder: crate::input::map_with_enum_key_op_input::Builder,
 ) -> ::std::result::Result<
     crate::input::map_with_enum_key_op_input::Builder,
     ::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() {
                     "map" => {
                         builder = builder.set_map(
                             crate::protocol_serde::shape_map_with_enum_key::de_map_with_enum_key(

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_null_in_non_sparse.rs

@@ -1,1 +94,94 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_null_in_non_sparse_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::NullInNonSparseInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::null_in_non_sparse_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(&headers, None)?;
         input.build()
     })
-25
+}
-26
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_null_in_non_sparse_http_response(
     #[allow(unused_variables)] output: crate::output::NullInNonSparseOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_null_in_non_sparse_output::ser_null_in_non_sparse_output_output_output(&output)?
-46
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-56
+}
-57
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_null_in_non_sparse_http_error(
     error: &crate::error::NullInNonSparseError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::NullInNonSparseError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-91
+            }
-92
+        }
     })
-94
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_primitive_int_header.rs

@@ -1,1 +147,149 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_primitive_int_header_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::PrimitiveIntHeaderInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::primitive_int_header_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(&headers, None)?;
         input.build()
     })
-25
+}
-26
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_primitive_int_header_http_response(
     #[allow(unused_variables)] output: crate::output::PrimitiveIntHeaderOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder =
             crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_headers(
                 &output, builder,
             )?;
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_primitive_int_header_output::ser_primitive_int_header_output_output_output(&output)?
-50
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-60
+}
-61
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_primitive_int_header_http_error(
     error: &crate::error::PrimitiveIntHeaderError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::PrimitiveIntHeaderError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-94
+            }
             crate::error::PrimitiveIntHeaderError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-119
+            }
-120
+        }
     })
-122
+}
-123
 pub fn ser_primitive_int_header_headers(
     input: &crate::output::PrimitiveIntHeaderOutput,
     mut builder: ::http::response::Builder,
 ) -> std::result::Result<::http::response::Builder, ::aws_smithy_types::error::operation::BuildError>
--
+{
     mut builder: ::http_1x::response::Builder,
 ) -> std::result::Result<
     ::http_1x::response::Builder,
     ::aws_smithy_types::error::operation::BuildError,
 > {
-131
+    {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(input.field);
         let formatted_1 = encoder.encode();
         if !formatted_1.is_empty() {
             let header_value = formatted_1;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "field",
                     format!(
                         "`{}` cannot be used as a header value: {}",
                         &header_value, err
                     ),
-143
+                )
             })?;
             builder = builder.header("x-field", header_value);
-146
+        }

↧ Expand context

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_primitive_int_op.rs

@@ -1,1 +125,128 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_primitive_int_op_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::PrimitiveIntOpInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::primitive_int_op_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_primitive_int_op::de_primitive_int_op(
                 bytes.as_ref(),
                 input,
             )?;
-35
+        }
         input.build()
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_primitive_int_op_http_response(
     #[allow(unused_variables)] output: crate::output::PrimitiveIntOpOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_primitive_int_op_output::ser_primitive_int_op_output_output_output(&output)?
-59
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-69
+}
-70
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_primitive_int_op_http_error(
     error: &crate::error::PrimitiveIntOpError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::PrimitiveIntOpError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-104
+            }
-105
+        }
     })
-107
+}
-108

↧ Expand context

 pub(crate) fn de_primitive_int_op(
     value: &[u8],
     mut builder: crate::input::primitive_int_op_input::Builder,
 ) -> ::std::result::Result<
     crate::input::primitive_int_op_input::Builder,
     ::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() {
                     "value" => {
                         if let Some(v) =
                             ::aws_smithy_json::deserialize::token::expect_number_or_null(

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_query_precedence.rs

@@ -1,1 +110,110 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_query_precedence_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::QueryPrecedenceInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::query_precedence_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let query_string = uri.query().unwrap_or("");
         let pairs = ::form_urlencoded::parse(query_string.as_bytes());
         let mut query_params: ::std::collections::HashMap<
             ::std::string::String,
             ::std::string::String,
         > = ::std::collections::HashMap::new();
         let mut foo_seen = false;
         for (k, v) in pairs {
             if !foo_seen && k == "bar" {
                 input = input.set_foo(crate::protocol_serde::shape_query_precedence_input::de_foo(
                     &v,
                 )?);
                 foo_seen = true;
-35
+            }
             query_params
                 .entry(String::from(k))
                 .or_insert_with(|| String::from(v));
-39
+        }
         input = input.set_baz(Some(query_params));
         input.build()
     })
-43
+}
-44
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_query_precedence_http_response(
     #[allow(unused_variables)] output: crate::output::QueryPrecedenceOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-72
+}
-73
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_query_precedence_http_error(
     error: &crate::error::QueryPrecedenceError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::QueryPrecedenceError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-107
+            }
-108
+        }
     })
-110
+}

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/protocol_serde/shape_status_response.rs

@@ -1,1 +95,95 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_status_response_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::StatusResponseInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::status_response_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(&headers, None)?;
         input.build()
     })
-25
+}
-26
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_status_response_http_response(
     #[allow(unused_variables)] output: crate::output::StatusResponseOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/json",
         );
         let status = output.field;
         let http_status: u16 = status.try_into().map_err(::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection::InvalidHttpStatusCode)?;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_status_response_output::ser_status_response_output_output_output(&output)?
-47
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-57
+}
-58
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_status_response_http_error(
     error: &crate::error::StatusResponseError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::StatusResponseError::ExtraError(output) => {
                 let payload =
                     crate::protocol_serde::shape_extra_error::ser_extra_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     ::http_1x::header::HeaderName::from_static("x-amzn-errortype"),
                     "ExtraError",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-92
+            }
-93
+        }
     })
-95
+}

Server Test

Files changed: