Server Test

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

@@ -0,1 +0,204 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedUniqueItemsInput`](crate::input::MalformedUniqueItemsInput) using modelled bindings.
     pub struct MalformedUniqueItemsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedUniqueItemsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedUniqueItemsInputFuture {
     type Output = Result<
         crate::input::MalformedUniqueItemsInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     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)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUniqueItemsInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUniqueItemsInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedUniqueItemsInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUniqueItemsOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_unique_items::ser_malformed_unique_items_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedUniqueItemsError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_unique_items::ser_malformed_unique_items_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_unique_items_test {
-+
     /// When the list has duplicated items, the response should be a 400
     /// ValidationException.
     /// Test ID: RestJsonMalformedUniqueItemsDuplicateItems
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_unique_items_duplicate_items_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = ::http::Request::builder()
                 .uri("/MalformedUniqueItems")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_legacy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "{ \"set\" : [\"a\", \"a\", \"b\", \"c\"] }".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::UniqueItemsServiceConfig::builder().build();
             let service = crate::service::UniqueItemsService::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_unique_items(move |input: crate::input::MalformedUniqueItemsInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedUniqueItemsOutput, crate::error::MalformedUniqueItemsError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-+
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "ValidationException")];
             ::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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value with repeated values at indices [0, 1] at '/set' failed to satisfy constraint: Member must have unique values\",\n  \"fieldList\" : [{\"message\": \"Value with repeated values at indices [0, 1] at '/set' failed to satisfy constraint: Member must have unique values\", \"path\": \"/set\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-+
+        }
-+
+    }
-+
     /// When the list has duplicated blobs, the response should be a 400
     /// ValidationException.
     /// Test ID: RestJsonMalformedUniqueItemsDuplicateBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_unique_items_duplicate_blobs_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
                         let mut http_request = ::http::Request::builder()
                             .uri("/MalformedUniqueItems")
                             .method("POST")
             .header("content-type", "application/json")
             .body(::aws_smithy_legacy_http_server::body::Body::from(
                             ::bytes::Bytes::copy_from_slice(
                                 &::aws_smithy_protocol_test::decode_body_data("{ \"complexSet\" : [{\"foo\": true, \"blob\": \"YmxvYg==\"}, {\"foo\": true, \"blob\": \"b3RoZXJibG9i\"}, {\"foo\": true, \"blob\": \"YmxvYg==\"}] }".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::UniqueItemsServiceConfig::builder().build();
             let service = crate::service::UniqueItemsService::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_unique_items(move |input: crate::input::MalformedUniqueItemsInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedUniqueItemsOutput, crate::error::MalformedUniqueItemsError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-+
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 ::http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "ValidationException")];
             ::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())
                 .await
                 .expect("unable to extract body to bytes");
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "{ \"message\" : \"1 validation error detected. Value with repeated values at indices [0, 2] at '/complexSet' failed to satisfy constraint: Member must have unique values\",\n  \"fieldList\" : [{\"message\": \"Value with repeated values at indices [0, 2] at '/complexSet' failed to satisfy constraint: Member must have unique values\", \"path\": \"/complexSet\"}]}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             );
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/operation_shape.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 pub struct MalformedUniqueItems;
-+
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for MalformedUniqueItems {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "com.amazonaws.constraints#MalformedUniqueItems",
             "com.amazonaws.constraints",
             "MalformedUniqueItems",
         );
-+
     type Input = crate::input::MalformedUniqueItemsInput;
     type Output = crate::output::MalformedUniqueItemsOutput;
     type Error = crate::error::MalformedUniqueItemsError;
-+
+}
-+
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for MalformedUniqueItems
-+
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-+
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-+
+    }
-+
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/output.rs

@@ -0,1 +0,33 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct MalformedUniqueItemsOutput {}
 impl MalformedUniqueItemsOutput {
     /// Creates a new builder-style object to manufacture [`MalformedUniqueItemsOutput`](crate::output::MalformedUniqueItemsOutput).
     pub fn builder() -> crate::output::malformed_unique_items_output::Builder {
         crate::output::malformed_unique_items_output::Builder::default()
-+
+    }
-+
+}
 /// See [`MalformedUniqueItemsOutput`](crate::output::MalformedUniqueItemsOutput).
 pub mod malformed_unique_items_output {
-+
     impl ::std::convert::From<Builder> for crate::output::MalformedUniqueItemsOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`MalformedUniqueItemsOutput`](crate::output::MalformedUniqueItemsOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`MalformedUniqueItemsOutput`](crate::output::MalformedUniqueItemsOutput).
         pub fn build(self) -> crate::output::MalformedUniqueItemsOutput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::output::MalformedUniqueItemsOutput {
             crate::output::MalformedUniqueItemsOutput {}
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde.rs

@@ -0,1 +0,20 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) mod shape_malformed_unique_items;
-+
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
-+
+    }
-+
+}
-+
 pub(crate) mod shape_validation_exception;
-+
 pub(crate) mod shape_complex_set;
-+
 pub(crate) mod shape_simple_set;
-+
 pub(crate) mod shape_complex_set_struct;
-+
 pub(crate) mod shape_validation_exception_field;

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde/shape_complex_set.rs

@@ -0,1 +0,53 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_complex_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::complex_set_unconstrained::ComplexSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-+
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-+
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             let mut items = Vec::new();
             loop {
                 match tokens.peek() {
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         tokens.next().transpose().unwrap();
                         break;
-+
+                    }
                     _ => {
                         let value =
                             crate::protocol_serde::shape_complex_set_struct::de_complex_set_struct(
                                 tokens,
                             )?;
                         if let Some(value) = value {
                             items.push(value);
                         } else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-+
+                        }
-+
+                    }
-+
+                }
-+
+            }
             Ok(Some(
                 crate::unconstrained::complex_set_unconstrained::ComplexSetUnconstrained(items),
             ))
-+
+        }
         _ => Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "expected start array or null",
             ),
         ),
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde/shape_complex_set_struct.rs

@@ -0,1 +0,60 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_complex_set_struct<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::model::ComplexSetStruct>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-+
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-+
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             #[allow(unused_mut)]
             let mut builder = crate::model::complex_set_struct::Builder::default();
             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() {
                             "foo" => {
                                 builder = builder.set_foo(
                                     ::aws_smithy_json::deserialize::token::expect_bool_or_null(
                                         tokens.next(),
                                     )?,
                                 );
-+
+                            }
                             "blob" => {
                                 builder = builder.set_blob(
                                     ::aws_smithy_json::deserialize::token::expect_blob_or_null(
                                         tokens.next(),
                                     )?,
                                 );
-+
+                            }
                             _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
-+
+                        }
-+
+                    }
                     other => {
                         return Err(
                             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                 format!("expected object key or end object, found: {other:?}"),
                             ),
-+
+                        )
-+
+                    }
-+
+                }
-+
+            }
             Ok(Some(builder.build()))
-+
+        }
         _ => Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "expected start object or null",
             ),
         ),
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_unique_items.rs

@@ -0,1 +0,150 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_malformed_unique_items_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
 ) -> std::result::Result<
     crate::input::MalformedUniqueItemsInput,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-+
+>
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::malformed_unique_items_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?;
         if !bytes.is_empty() {
             ::aws_smithy_legacy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items(
                 bytes.as_ref(),
                 input,
             )?;
-+
+        }
         input.build()?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_malformed_unique_items_http_response(
     #[allow(unused_variables)] output: crate::output::MalformedUniqueItemsOutput,
 ) -> std::result::Result<
     ::aws_smithy_legacy_http_server::response::Response,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
             builder,
             ::http::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_legacy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_legacy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_malformed_unique_items_http_error(
     error: &crate::error::MalformedUniqueItemsError,
 ) -> std::result::Result<
     ::aws_smithy_legacy_http_server::response::Response,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::MalformedUniqueItemsError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     "application/json",
                 );
                 builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_legacy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_legacy_http_server::body::to_boxed(payload))?
-+
+            }
-+
+        }
     })
-+
+}
-+
 pub(crate) fn de_malformed_unique_items(
     value: &[u8],
     mut builder: crate::input::malformed_unique_items_input::Builder,
 ) -> ::std::result::Result<
     crate::input::malformed_unique_items_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() {
                     "complexSet" => {
                         builder = builder.set_complex_set(
                             crate::protocol_serde::shape_complex_set::de_complex_set(tokens)?,
                         );
-+
+                    }
                     "set" => {
                         builder = builder.set_set(
                             crate::protocol_serde::shape_simple_set::de_simple_set(tokens)?,
                         );
-+
+                    }
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
-+
+                }
-+
+            }
             other => {
                 return Err(
                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                         "expected object key or end object, found: {other:?}"
                     )),
-+
+                )
-+
+            }
-+
+        }
-+
+    }
     if tokens.next().is_some() {
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "found more JSON tokens after completing parsing",
             ),
         );
-+
+    }
     Ok(builder)
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde/shape_simple_set.rs

@@ -0,1 +0,54 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_simple_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::simple_set_unconstrained::SimpleSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-+
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-+
+{
     match tokens.next().transpose()? {
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             let mut items = Vec::new();
             loop {
                 match tokens.peek() {
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         tokens.next().transpose().unwrap();
                         break;
-+
+                    }
                     _ => {
                         let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
                             tokens.next(),
                         )?
                         .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                         .transpose()?;
                         if let Some(value) = value {
                             items.push(value);
                         } else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-+
+                        }
-+
+                    }
-+
+                }
-+
+            }
             Ok(Some(
                 crate::unconstrained::simple_set_unconstrained::SimpleSetUnconstrained(items),
             ))
-+
+        }
         _ => Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "expected start array or null",
             ),
         ),
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde/shape_validation_exception.rs

@@ -0,1 +0,35 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_validation_exception_error(
     value: &crate::error::ValidationException,
 ) -> ::std::result::Result<String, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = ::std::string::String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_validation_exception::ser_validation_exception(
         &mut object,
         value,
     )?;
     object.finish();
     Ok(out)
-+
+}
-+
 pub fn ser_validation_exception(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::error::ValidationException,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     if let Some(var_1) = &input.field_list {
         let mut array_2 = object.key("fieldList").start_array();
         for item_3 in var_1 {
-+
+            {
                 #[allow(unused_mut)]
                 let mut object_4 = array_2.value().start_object();
                 crate::protocol_serde::shape_validation_exception_field::ser_validation_exception_field(&mut object_4, item_3)?;
                 object_4.finish();
-+
+            }
-+
+        }
         array_2.finish();
-+
+    }
-+
+    {
         object.key("message").string(input.message.as_str());
-+
+    }
     Ok(())
-+
+}

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/protocol_serde/shape_validation_exception_field.rs

@@ -0,1 +0,13 @@

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

tmp-codegen-diff/codegen-server-test/unique_items-http0x/rust-server-codegen/src/service.rs

@@ -0,1 +0,734 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// The service builder for [`UniqueItemsService`].
 ///
 /// Constructed via [`UniqueItemsService::builder`].
 pub struct UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {
     malformed_unique_items: Option<::aws_smithy_legacy_http_server::routing::Route<Body>>,
     layer: L,
     http_plugin: HttpPl,
     model_plugin: ModelPl,
-+
+}
-+
 impl<Body, L, HttpPl, ModelPl> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {
     /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_legacy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_legacy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use unique_items_http0x::{UniqueItemsService, UniqueItemsServiceConfig};
     ///
     /// use unique_items_http0x::{input, output, error};
     ///
     /// async fn handler(input: input::MalformedUniqueItemsInput) -> Result<output::MalformedUniqueItemsOutput, error::MalformedUniqueItemsError> {
     ///     todo!()
     /// }
     ///
     /// let config = UniqueItemsServiceConfig::builder().build();
     /// let app = UniqueItemsService::builder(config)
     ///     .malformed_unique_items(handler)
     ///     /* Set other handlers */
     ///     .build()
     ///     .unwrap();
     /// # let app: UniqueItemsService<::aws_smithy_legacy_http_server::routing::RoutingService<::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<::aws_smithy_legacy_http_server::routing::Route>, ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>> = app;
     /// ```
     ///
                     pub fn malformed_unique_items<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self
                     where
                         HandlerType: ::aws_smithy_legacy_http_server::operation::Handler<crate::operation_shape::MalformedUniqueItems, HandlerExtractors>,
-+
                         ModelPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ::aws_smithy_legacy_http_server::operation::IntoService<crate::operation_shape::MalformedUniqueItems, HandlerType>
                         >,
                         ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
-+
+                            <
                                 ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_legacy_http_server::plugin::Plugin<
                                     UniqueItemsService<L>,
                                     crate::operation_shape::MalformedUniqueItems,
                                     ModelPl::Output
-+
+                                >
                             >::Output
                         >,
-+
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
-+
-+
+                    {
         use ::aws_smithy_legacy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_legacy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::MalformedUniqueItems::from_handler(handler);
         let svc = self.model_plugin.apply(svc);
         let svc =
             ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
                 .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.malformed_unique_items_custom(svc)
-+
+    }
-+
     /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_legacy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_legacy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use unique_items_http0x::{UniqueItemsService, UniqueItemsServiceConfig};
     ///
     /// use unique_items_http0x::{input, output, error};
     ///
     /// async fn handler(input: input::MalformedUniqueItemsInput) -> Result<output::MalformedUniqueItemsOutput, error::MalformedUniqueItemsError> {
     ///     todo!()
     /// }
     ///
     /// let config = UniqueItemsServiceConfig::builder().build();
     /// let svc = ::tower::util::service_fn(handler);
     /// let app = UniqueItemsService::builder(config)
     ///     .malformed_unique_items_service(svc)
     ///     /* Set other handlers */
     ///     .build()
     ///     .unwrap();
     /// # let app: UniqueItemsService<::aws_smithy_legacy_http_server::routing::RoutingService<::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<::aws_smithy_legacy_http_server::routing::Route>, ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>> = app;
     /// ```
     ///
                     pub fn malformed_unique_items_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self
                     where
                         S: ::aws_smithy_legacy_http_server::operation::OperationService<crate::operation_shape::MalformedUniqueItems, ServiceExtractors>,
-+
                         ModelPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ::aws_smithy_legacy_http_server::operation::Normalize<crate::operation_shape::MalformedUniqueItems, S>
                         >,
                         ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_legacy_http_server::plugin::Plugin<
                             UniqueItemsService<L>,
                             crate::operation_shape::MalformedUniqueItems,
-+
+                            <
                                 ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_legacy_http_server::plugin::Plugin<
                                     UniqueItemsService<L>,
                                     crate::operation_shape::MalformedUniqueItems,
                                     ModelPl::Output
-+
+                                >
                             >::Output
                         >,
-+
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
-+
-+
+                    {
         use ::aws_smithy_legacy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_legacy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::MalformedUniqueItems::from_service(service);
         let svc = self.model_plugin.apply(svc);
         let svc =
             ::aws_smithy_legacy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
                 .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.malformed_unique_items_custom(svc)
-+
+    }
-+
     /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) to a custom [`Service`](tower::Service).
     /// not constrained by the Smithy contract.
     fn malformed_unique_items_custom<S>(mut self, svc: S) -> Self
     where
         S: ::tower::Service<
                 ::http::Request<Body>,
                 Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>,
                 Error = ::std::convert::Infallible,
             > + Clone
             + Send
             + 'static,
         S::Future: Send + 'static,
-+
+    {
         self.malformed_unique_items =
             Some(::aws_smithy_legacy_http_server::routing::Route::new(svc));
         self
-+
+    }
-+
+}
-+
 impl<Body, L, HttpPl, ModelPl> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {
     /// Constructs a [`UniqueItemsService`] from the arguments provided to the builder.
     ///
     /// Forgetting to register a handler for one or more operations will result in an error.
     ///
     /// Check out [`UniqueItemsServiceBuilder::build_unchecked`] if you'd prefer the service to return status code 500 when an
     /// unspecified route is requested.
     pub fn build(
         self,
     ) -> ::std::result::Result<
         UniqueItemsService<
             ::aws_smithy_legacy_http_server::routing::RoutingService<
                 ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<L::Service>,
                 ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
             >,
         >,
         MissingOperationsError,
-+
+    >
     where
         L: ::tower::Layer<::aws_smithy_legacy_http_server::routing::Route<Body>>,
-+
+    {
         let router = {
             use ::aws_smithy_legacy_http_server::operation::OperationShape;
             let mut missing_operation_names = std::collections::HashMap::new();
             if self.malformed_unique_items.is_none() {
                 missing_operation_names.insert(
                     crate::operation_shape::MalformedUniqueItems::ID,
                     ".malformed_unique_items()",
                 );
-+
+            }
             if !missing_operation_names.is_empty() {
                 return Err(MissingOperationsError {
                     operation_names2setter_methods: missing_operation_names,
                 });
-+
+            }
             let unexpected_error_msg = "this should never panic since we are supposed to check beforehand that a handler has been registered for this operation; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues";
-+
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter::from_iter([(
                 request_specs::malformed_unique_items(),
                 self.malformed_unique_items.expect(unexpected_error_msg),
             )])
         };
         let svc = ::aws_smithy_legacy_http_server::routing::RoutingService::new(router);
         let svc = svc.map(|s| s.layer(self.layer));
         Ok(UniqueItemsService { svc })
-+
+    }
-+
     /// Constructs a [`UniqueItemsService`] from the arguments provided to the builder.
     /// Operations without a handler default to returning 500 Internal Server Error to the caller.
     ///
     /// Check out [`UniqueItemsServiceBuilder::build`] if you'd prefer the builder to fail if one or more operations do
     /// not have a registered handler.
     pub fn build_unchecked(self) -> UniqueItemsService<L::Service>
     where
         Body: Send + 'static,
         L: ::tower::Layer<
             ::aws_smithy_legacy_http_server::routing::RoutingService<
                 ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<
                     ::aws_smithy_legacy_http_server::routing::Route<Body>,
                 >,
                 ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
             >,
         >,
-+
+    {
         let router =
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter::from_iter([(
                 request_specs::malformed_unique_items(),
                 self.malformed_unique_items.unwrap_or_else(|| {
                     let svc = ::aws_smithy_legacy_http_server::operation::MissingFailure::<
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
                     >::default();
                     ::aws_smithy_legacy_http_server::routing::Route::new(svc)
                 }),
             )]);
         let svc = self
             .layer
             .layer(::aws_smithy_legacy_http_server::routing::RoutingService::new(router));
         UniqueItemsService { svc }
-+
+    }
-+
+}
-+
 /// The error encountered when calling the [`UniqueItemsServiceBuilder::build`] method if one or more operation handlers are not
 /// specified.
 #[derive(Debug)]
 pub struct MissingOperationsError {
     operation_names2setter_methods:
         std::collections::HashMap<::aws_smithy_legacy_http_server::shape_id::ShapeId, &'static str>,
-+
+}
-+
 impl std::fmt::Display for MissingOperationsError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "You must specify a handler for all operations attached to `UniqueItemsService`.\n\
                             We are missing handlers for the following operations:\n",
         )?;
         for operation_name in self.operation_names2setter_methods.keys() {
             writeln!(f, "- {}", operation_name.absolute())?;
-+
+        }
-+
         writeln!(f, "\nUse the dedicated methods on `UniqueItemsServiceBuilder` to register the missing handlers:")?;
         for setter_name in self.operation_names2setter_methods.values() {
             writeln!(f, "- {}", setter_name)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
-+
 impl std::error::Error for MissingOperationsError {}
-+
 mod request_specs {
     pub(super) fn malformed_unique_items(
     ) -> ::aws_smithy_legacy_http_server::routing::request_spec::RequestSpec {
         ::aws_smithy_legacy_http_server::routing::request_spec::RequestSpec::new(
                     ::http::Method::POST,
                     ::aws_smithy_legacy_http_server::routing::request_spec::UriSpec::new(
                         ::aws_smithy_legacy_http_server::routing::request_spec::PathAndQuerySpec::new(
                             ::aws_smithy_legacy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
     ::aws_smithy_legacy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedUniqueItems")),
 ]),
                             ::aws_smithy_legacy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
 ])
-+
+                        )
                     ),
-+
+                )
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 ///
 /// See the [root](crate) documentation for more information.
 #[derive(Clone)]
 pub struct UniqueItemsService<
     S = ::aws_smithy_legacy_http_server::routing::RoutingService<
         ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<
             ::aws_smithy_legacy_http_server::routing::Route<
                 ::aws_smithy_legacy_http_server::body::BoxBody,
             >,
         >,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     >,
 > {
     // This is the router wrapped by layers.
     svc: S,
-+
+}
-+
 impl UniqueItemsService<()> {
     /// Constructs a builder for [`UniqueItemsService`].
     /// You must specify a configuration object holding any plugins and layers that should be applied
     /// to the operations in this service.
     pub fn builder<
         Body,
         L,
         HttpPl: ::aws_smithy_legacy_http_server::plugin::HttpMarker,
         ModelPl: ::aws_smithy_legacy_http_server::plugin::ModelMarker,
     >(
         config: UniqueItemsServiceConfig<L, HttpPl, ModelPl>,
     ) -> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {
         UniqueItemsServiceBuilder {
             malformed_unique_items: None,
             layer: config.layers,
             http_plugin: config.http_plugins,
             model_plugin: config.model_plugins,
-+
+        }
-+
+    }
-+
     /// Constructs a builder for [`UniqueItemsService`].
     /// You must specify what plugins should be applied to the operations in this service.
     ///
     /// Use [`UniqueItemsService::builder_without_plugins`] if you don't need to apply plugins.
     ///
     /// Check out [`HttpPlugins`](::aws_smithy_legacy_http_server::plugin::HttpPlugins) and
     /// [`ModelPlugins`](::aws_smithy_legacy_http_server::plugin::ModelPlugins) if you need to apply
     /// multiple plugins.
     #[deprecated(
         since = "0.57.0",
         note = "please use the `builder` constructor and register plugins on the `UniqueItemsServiceConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
     )]
     pub fn builder_with_plugins<
         Body,
         HttpPl: ::aws_smithy_legacy_http_server::plugin::HttpMarker,
         ModelPl: ::aws_smithy_legacy_http_server::plugin::ModelMarker,
     >(
         http_plugin: HttpPl,
         model_plugin: ModelPl,
     ) -> UniqueItemsServiceBuilder<Body, ::tower::layer::util::Identity, HttpPl, ModelPl> {
         UniqueItemsServiceBuilder {
             malformed_unique_items: None,
             layer: ::tower::layer::util::Identity::new(),
             http_plugin,
             model_plugin,
-+
+        }
-+
+    }
-+
     /// Constructs a builder for [`UniqueItemsService`].
     ///
     /// Use [`UniqueItemsService::builder_with_plugins`] if you need to specify plugins.
     #[deprecated(
         since = "0.57.0",
         note = "please use the `builder` constructor instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
     )]
     pub fn builder_without_plugins<Body>() -> UniqueItemsServiceBuilder<
         Body,
         ::tower::layer::util::Identity,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
     > {
         Self::builder_with_plugins(
             ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
             ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
-+
+        )
-+
+    }
-+
+}
-+
 impl<S> UniqueItemsService<S> {
     /// Converts [`UniqueItemsService`] into a [`MakeService`](tower::make::MakeService).
     pub fn into_make_service(
         self,
     ) -> ::aws_smithy_legacy_http_server::routing::IntoMakeService<Self> {
         ::aws_smithy_legacy_http_server::routing::IntoMakeService::new(self)
-+
+    }
-+
     /// Converts [`UniqueItemsService`] into a [`MakeService`](tower::make::MakeService) with [`ConnectInfo`](::aws_smithy_legacy_http_server::request::connect_info::ConnectInfo).
     pub fn into_make_service_with_connect_info<C>(
         self,
     ) -> ::aws_smithy_legacy_http_server::routing::IntoMakeServiceWithConnectInfo<Self, C> {
         ::aws_smithy_legacy_http_server::routing::IntoMakeServiceWithConnectInfo::new(self)
-+
+    }
-+
+}
-+
 impl<S>
     UniqueItemsService<
         ::aws_smithy_legacy_http_server::routing::RoutingService<
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<S>,
             ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         >,
-+
+    >
-+
+{
     /// Applies a [`Layer`](::tower::Layer) uniformly to all routes.
     #[deprecated(
         since = "0.57.0",
         note = "please add layers to the `UniqueItemsServiceConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
     )]
     pub fn layer<L>(
         self,
         layer: &L,
     ) -> UniqueItemsService<
         ::aws_smithy_legacy_http_server::routing::RoutingService<
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<L::Service>,
             ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         >,
-+
+    >
     where
         L: ::tower::Layer<S>,
-+
+    {
         UniqueItemsService {
             svc: self.svc.map(|s| s.layer(layer)),
-+
+        }
-+
+    }
-+
     /// Applies [`Route::new`](::aws_smithy_legacy_http_server::routing::Route::new) to all routes.
     ///
     /// This has the effect of erasing all types accumulated via layers.
     pub fn boxed<B>(
         self,
     ) -> UniqueItemsService<
         ::aws_smithy_legacy_http_server::routing::RoutingService<
             ::aws_smithy_legacy_http_server::protocol::rest::router::RestRouter<
                 ::aws_smithy_legacy_http_server::routing::Route<B>,
             >,
             ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         >,
-+
+    >
     where
         S: ::tower::Service<
             ::http::Request<B>,
             Response = ::http::Response<::aws_smithy_legacy_http_server::body::BoxBody>,
             Error = std::convert::Infallible,
         >,
         S: Clone + Send + 'static,
         S::Future: Send + 'static,
-+
+    {
         self.layer(&::tower::layer::layer_fn(
             ::aws_smithy_legacy_http_server::routing::Route::new,
         ))
-+
+    }
-+
+}
-+
 impl<S, R> ::tower::Service<R> for UniqueItemsService<S>
 where
     S: ::tower::Service<R>,
-+
+{
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
-+
     fn poll_ready(
         &mut self,
         cx: &mut std::task::Context,
     ) -> std::task::Poll<::std::result::Result<(), Self::Error>> {
         self.svc.poll_ready(cx)
-+
+    }
-+
     fn call(&mut self, request: R) -> Self::Future {
         self.svc.call(request)
-+
+    }
-+
+}
-+
 /// An enumeration of all [operations](https://smithy.io/2.0/spec/service-types.html#operation) in UniqueItemsService.
 #[allow(clippy::enum_variant_names)]
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum Operation {
     MalformedUniqueItems,
-+
+}
-+
 impl Operation {
     /// Returns the [operations](https://smithy.io/2.0/spec/service-types.html#operation) [`ShapeId`](::aws_smithy_legacy_http_server::shape_id::ShapeId).
     pub fn shape_id(&self) -> ::aws_smithy_legacy_http_server::shape_id::ShapeId {
         match self {
             Operation::MalformedUniqueItems => {
                 ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
                     "com.amazonaws.constraints#MalformedUniqueItems",
                     "com.amazonaws.constraints",
                     "MalformedUniqueItems",
-+
+                )
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl<L>
     ::aws_smithy_legacy_http_server::service::ContainsOperation<
         crate::operation_shape::MalformedUniqueItems,
     > for UniqueItemsService<L>
-+
+{
     const VALUE: Operation = Operation::MalformedUniqueItems;
-+
+}
-+
 impl<S> ::aws_smithy_legacy_http_server::service::ServiceShape for UniqueItemsService<S> {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "com.amazonaws.constraints#UniqueItemsService",
             "com.amazonaws.constraints",
             "UniqueItemsService",
         );
-+
     const VERSION: Option<&'static str> = Some("");
-+
     type Protocol = ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1;
-+
     type Operations = Operation;
-+
+}
 /// Configuration for the [`UniqueItemsService`]. This is the central place where to register and
 /// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
 ///
 /// ```rust,no_run
 /// # use unique_items_http0x::UniqueItemsServiceConfig;
 /// # use ::aws_smithy_legacy_http_server::plugin::IdentityPlugin;
 /// # use ::tower::layer::util::Identity;
 /// # let authentication_plugin = IdentityPlugin;
 /// # let authorization_plugin = IdentityPlugin;
 /// # let server_request_id_provider_layer = Identity::new();
 /// let config = UniqueItemsServiceConfig::builder()
 ///     // Layers get executed first...
 ///     .layer(server_request_id_provider_layer)
 ///     // ...then HTTP plugins...
 ///     .http_plugin(authentication_plugin)
 ///     // ...and right after deserialization, model plugins.
 ///     .model_plugin(authorization_plugin)
 ///     .build();
 /// ```
 ///
 /// See the [`plugin`] system for details.
 ///
 /// [`plugin`]: ::aws_smithy_legacy_http_server::plugin
 #[derive(::std::fmt::Debug)]
 pub struct UniqueItemsServiceConfig<L, H, M> {
     layers: L,
     http_plugins: H,
     model_plugins: M,
-+
+}
-+
 impl UniqueItemsServiceConfig<(), (), ()> {
     /// Returns a builder to construct the configuration.
     pub fn builder() -> UniqueItemsServiceConfigBuilder<
         ::tower::layer::util::Identity,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
         ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
     > {
         UniqueItemsServiceConfigBuilder {
             layers: ::tower::layer::util::Identity::new(),
             http_plugins: ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
             model_plugins: ::aws_smithy_legacy_http_server::plugin::IdentityPlugin,
-+
+        }
-+
+    }
-+
+}
-+
 /// Builder returned by [`UniqueItemsServiceConfig::builder()`].
 #[derive(::std::fmt::Debug)]
 pub struct UniqueItemsServiceConfigBuilder<L, H, M> {
     pub(crate) layers: L,
     pub(crate) http_plugins: H,
     pub(crate) model_plugins: M,
-+
+}
-+
 impl<L, H, M> UniqueItemsServiceConfigBuilder<L, H, M> {
     /// Add a [`::tower::Layer`] to the service.
     pub fn layer<NewLayer>(
         self,
         layer: NewLayer,
     ) -> UniqueItemsServiceConfigBuilder<::tower::layer::util::Stack<NewLayer, L>, H, M> {
         UniqueItemsServiceConfigBuilder {
             layers: ::tower::layer::util::Stack::new(layer, self.layers),
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-+
+        }
-+
+    }
-+
     /// Add a HTTP [plugin] to the service.
     ///
     /// [plugin]: ::aws_smithy_legacy_http_server::plugin
     // We eagerly require `NewPlugin: HttpMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn http_plugin<NewPlugin: ::aws_smithy_legacy_http_server::plugin::HttpMarker>(
         self,
         http_plugin: NewPlugin,
     ) -> UniqueItemsServiceConfigBuilder<
         L,
         ::aws_smithy_legacy_http_server::plugin::PluginStack<NewPlugin, H>,
         M,
     > {
         UniqueItemsServiceConfigBuilder {
             layers: self.layers,
             http_plugins: ::aws_smithy_legacy_http_server::plugin::PluginStack::new(
                 http_plugin,
                 self.http_plugins,
             ),
             model_plugins: self.model_plugins,
-+
+        }
-+
+    }
-+
     /// Add a model [plugin] to the service.
     ///
     /// [plugin]: ::aws_smithy_legacy_http_server::plugin
     // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn model_plugin<NewPlugin: ::aws_smithy_legacy_http_server::plugin::ModelMarker>(
         self,
         model_plugin: NewPlugin,
     ) -> UniqueItemsServiceConfigBuilder<
         L,
         H,
         ::aws_smithy_legacy_http_server::plugin::PluginStack<NewPlugin, M>,
     > {
         UniqueItemsServiceConfigBuilder {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: ::aws_smithy_legacy_http_server::plugin::PluginStack::new(
                 model_plugin,
                 self.model_plugins,
             ),
-+
+        }
-+
+    }
-+
     /// Build the configuration.
     pub fn build(self) -> super::UniqueItemsServiceConfig<L, H, M> {
         super::UniqueItemsServiceConfig {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-+
+        }
-+
+    }
-+
+}
 /// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
 ///
 /// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
 /// of the service and any operations _not_ specified will be placed in the opposing group.
 ///
 /// # Example
 ///
 /// ```rust
 /// scope! {
 ///     /// Includes [`MalformedUniqueItems`], excluding all other operations.
 ///     struct ScopeA {
 ///         includes: [MalformedUniqueItems]
 ///     }
 /// }
 ///
 /// scope! {
 ///     /// Excludes [`MalformedUniqueItems`], excluding all other operations.
 ///     struct ScopeB {
 ///         excludes: [MalformedUniqueItems]
 ///     }
 /// }
 ///
 /// # use unique_items_http0x::server::plugin::{Plugin, Scoped};
 /// # use unique_items_http0x::scope;
 /// # struct MockPlugin;
 /// # impl<S, Op, T> Plugin<S, Op, T> for MockPlugin { type Output = u32; fn apply(&self, input: T) -> u32 { 3 } }
 /// # let scoped_a = Scoped::new::<ScopeA>(MockPlugin);
 /// # let scoped_b = Scoped::new::<ScopeB>(MockPlugin);
 /// # let a = Plugin::<(), unique_items_http0x::operation_shape::MalformedUniqueItems, u64>::apply(&scoped_a, 6);
 /// # let b = Plugin::<(), unique_items_http0x::operation_shape::MalformedUniqueItems, u64>::apply(&scoped_b, 6);
 /// # assert_eq!(a, 3_u32);
 /// # assert_eq!(b, 6_u64);
 /// ```
 #[macro_export]
 macro_rules! scope {
                     // Completed, render impls
                     (@ $ name: ident, $ contains: ident () ($($ temp: ident)*) ($($ not_member: ident)*)) => {
                         $(
                             impl $ crate::server::plugin::scoped::Membership<$ temp> for $ name {
                                 type Contains = $ crate::server::plugin::scoped::$ contains;
-+
+                            }
                         )*
                         $(
                             impl $ crate::server::plugin::scoped::Membership<$ not_member> for $ name {
                                 type Contains = $ crate::server::plugin::scoped::$ contains;
-+
+                            }
                         )*
                     };
                     // All `not_member`s exhausted, move `temp` into `not_member`
                     (@ $ name: ident, $ contains: ident ($($ member: ident)*) ($($ temp: ident)*) ()) => {
                         scope! { @ $ name, $ contains ($($ member)*) () ($($ temp)*) }
                     };
-+
                         // MalformedUniqueItems match found, pop from both `member` and `not_member`
                         (@ $ name: ident, $ contains: ident (MalformedUniqueItems $($ member: ident)*) ($($ temp: ident)*) (MalformedUniqueItems $($ not_member: ident)*)) => {
                             scope! { @ $ name, $ contains ($($ member)*) ($($ temp)*) ($($ not_member)*) }
                         };
                         // MalformedUniqueItems match not found, pop from `not_member` into `temp` stack
                         (@ $ name: ident, $ contains: ident (MalformedUniqueItems $($ member: ident)*) ($($ temp: ident)*) ($ other: ident $($ not_member: ident)*)) => {
                             scope! { @ $ name, $ contains (MalformedUniqueItems $($ member)*) ($ other $($ temp)*) ($($ not_member)*) }
                         };
-+
-+
+                    (
                         $(#[$ attrs:meta])*
                         $ vis:vis struct $ name:ident {
                             includes: [$($ include:ident),*]
-+
+                        }
                     ) => {
                         use $ crate::operation_shape::*;
                         $ crate::server::scope! {
                             $(#[$ attrs])*
                             $ vis struct $ name {
                                 includes: [$($ include),*],
                                 excludes: []
-+
+                            }
-+
+                        }
                         scope! { @ $ name, False ($($ include)*) () (MalformedUniqueItems) }
                     };
-+
+                    (
                         $(#[$ attrs:meta])*
                         $ vis:vis struct $ name:ident {
                             excludes: [$($ exclude:ident),*]
-+
+                        }
                     ) => {
                         use $ crate::operation_shape::*;
-+
                         $ crate::server::scope! {
                             $(#[$ attrs])*
                             $ vis struct $ name {
                                 includes: [],
                                 excludes: [$($ exclude),*]
-+
+                            }
-+
+                        }
                         scope! { @ $ name, True ($($ exclude)*) () (MalformedUniqueItems) }
                     };
-+
+                }

Server Test

Files changed: