Server Test

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

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

 #![allow(rustdoc::invalid_html_tags)]
 #![forbid(unsafe_code)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //! Confounds model generation machinery with lots of problematic casing
-23
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 //! A fast and customizable Rust implementation of the AcronymInsideService Smithy service.
 //!
 //! # Using AcronymInsideService
 //!
 //! The primary entrypoint is [`AcronymInsideService`]: 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 [`AcronymInsideService::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`], and [`crate::output`],
 //! modules provide the types used in each operation.
 //!
 //! ### Running on Hyper
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! # async fn dummy() {
 //! use naming_test_casing::{AcronymInsideService, AcronymInsideServiceConfig};
 //! use naming_test_casing::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! # let app = AcronymInsideService::builder(
 //! #     AcronymInsideServiceConfig::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 naming_test_casing::server::routing::LambdaHandler;
 //! use naming_test_casing::AcronymInsideService;
 //!
 //! # async fn dummy() {
 //! # let app = AcronymInsideService::builder(
 //! #     AcronymInsideServiceConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let handler = LambdaHandler::new(app);
 //! lambda_http::run(handler).await.unwrap();
 //! # }
 //! ```
 //!
 //! # Building the AcronymInsideService
 //!
 //! To construct [`AcronymInsideService`] we use [`AcronymInsideServiceBuilder`] returned by [`AcronymInsideService::builder`].
 //!
 //! ## Plugins
 //!
 //! The [`AcronymInsideService::builder`] method, returning [`AcronymInsideServiceBuilder`],
 //! 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 naming_test_casing::server::plugin::IdentityPlugin as LoggingPlugin;
 //! # use naming_test_casing::server::plugin::IdentityPlugin as MetricsPlugin;
 //! # use ::hyper::Body;
 //! # use ::hyper::body::Incoming;
 //! use naming_test_casing::server::plugin::HttpPlugins;
 //! use naming_test_casing::{AcronymInsideService, AcronymInsideServiceConfig, AcronymInsideServiceBuilder};
 //!
 //! let http_plugins = HttpPlugins::new()
 //!         .push(LoggingPlugin)
 //!         .push(MetricsPlugin);
 //! let config = AcronymInsideServiceConfig::builder().build();
 //! let builder: AcronymInsideServiceBuilder<Body, _, _, _> = AcronymInsideService::builder(config);
 //! let builder: AcronymInsideServiceBuilder<::hyper::body::Incoming, _, _, _> = AcronymInsideService::builder(config);
 //! ```
 //!
 //! Check out [`crate::server::plugin`] to learn more about plugins.
 //!
 //! ## Handlers
 //!
 //! [`AcronymInsideServiceBuilder`] 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 +228,235 @@

↥ 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 [`AcronymInsideServiceBuilder`] into [`AcronymInsideService`] using either [`AcronymInsideServiceBuilder::build`] or [`AcronymInsideServiceBuilder::build_unchecked`].
 //!

 //! [`AcronymInsideServiceBuilder::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.
 //!
 //! [`AcronymInsideServiceBuilder::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.
 //! [`AcronymInsideServiceBuilder::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 naming_test_casing::{AcronymInsideService, AcronymInsideServiceConfig};
 //! use naming_test_casing::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = AcronymInsideServiceConfig::builder().build();
 //!    let app = AcronymInsideService::builder(config)
 //!        .do_nothing(do_nothing)
 //!        .build()
 //!        .expect("failed to build an instance of AcronymInsideService");
 //!
 //!    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 naming_test_casing::{input, output};
 //!
 //! async fn do_nothing(input: input::DoNothingInput) -> output::DoNothingOutput {
 //!     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::{
     AcronymInsideService, AcronymInsideServiceBuilder, AcronymInsideServiceConfig,
     AcronymInsideServiceConfigBuilder, MissingOperationsError,
 };
-210
 /// 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::*;
-215
+}

↧ Expand context

-216
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-219
 /// All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-222
 /// Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-225
 /// All operations that this crate can perform.
 pub mod operation;
-228
 /// A collection of types representing each operation defined in the service closure.
 ///
 /// The [plugin system](::aws_smithy_http_server::plugin) makes use of these
 /// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to
 /// parameterize [`Plugin`](::aws_smithy_http_server::plugin::Plugin) implementations. Their traits, such as
 /// [`OperationShape`](::aws_smithy_http_server::operation::OperationShape), can be used to provide
 /// operation specific information to the [`Layer`](::tower::Layer) being applied.

tmp-codegen-diff/codegen-server-test/naming_test_ops-http0x/rust-server-codegen/src/error.rs

@@ -0,1 +0,376 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Error type for the `RPCEcho` operation.
 /// Each variant represents an error that can occur for the `RPCEcho` operation.
 #[derive(::std::fmt::Debug)]
 pub enum RPCEchoError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationException(crate::error::ValidationException),
-+
+}
 impl ::std::fmt::Display for RPCEchoError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             RPCEchoError::ValidationException(_inner) => _inner.fmt(f),
-+
+        }
-+
+    }
-+
+}
 impl RPCEchoError {
     /// Returns `true` if the error kind is `RPCEchoError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(&self, RPCEchoError::ValidationException(_))
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             RPCEchoError::ValidationException(_inner) => _inner.name(),
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for RPCEchoError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             RPCEchoError::ValidationException(_inner) => Some(_inner),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::ValidationException> for crate::error::RPCEchoError {
     fn from(variant: crate::error::ValidationException) -> crate::error::RPCEchoError {
         Self::ValidationException(variant)
-+
+    }
-+
+}
-+
 /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationException {
     /// A summary of the validation failure.
     pub message: ::std::string::String,
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
-+
+}
 impl ValidationException {
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
         self.field_list.as_deref()
-+
+    }
-+
+}
 impl ValidationException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-+
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "ValidationException"
-+
+    }
-+
+}
 impl ::std::fmt::Display for ValidationException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ValidationException")?;
-+
+        {
             ::std::write!(f, ": {}", &self.message)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl ::std::error::Error for ValidationException {}
 impl ValidationException {
     /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
     pub fn builder() -> crate::error::validation_exception::Builder {
         crate::error::validation_exception::Builder::default()
-+
+    }
-+
+}
-+
 /// Error type for the `Match` operation.
 /// Each variant represents an error that can occur for the `Match` operation.
 #[derive(::std::fmt::Debug)]
 pub enum MatchError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationException(crate::error::ValidationException),
-+
+}
 impl ::std::fmt::Display for MatchError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             MatchError::ValidationException(_inner) => _inner.fmt(f),
-+
+        }
-+
+    }
-+
+}
 impl MatchError {
     /// Returns `true` if the error kind is `MatchError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(&self, MatchError::ValidationException(_))
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             MatchError::ValidationException(_inner) => _inner.name(),
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for MatchError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             MatchError::ValidationException(_inner) => Some(_inner),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::ValidationException> for crate::error::MatchError {
     fn from(variant: crate::error::ValidationException) -> crate::error::MatchError {
         Self::ValidationException(variant)
-+
+    }
-+
+}
-+
 /// Error type for the `ErrCollisions` operation.
 /// Each variant represents an error that can occur for the `ErrCollisions` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ErrCollisionsError {
     #[allow(missing_docs)] // documentation missing in model
     CollidingError(crate::error::CollidingError),
     /// This will be renamed to CollidingError
     CollidingException(crate::error::CollidingException),
-+
+}
 impl ::std::fmt::Display for ErrCollisionsError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ErrCollisionsError::CollidingError(_inner) => _inner.fmt(f),
             ErrCollisionsError::CollidingException(_inner) => _inner.fmt(f),
-+
+        }
-+
+    }
-+
+}
 impl ErrCollisionsError {
     /// Returns `true` if the error kind is `ErrCollisionsError::CollidingError`.
     pub fn is_colliding_error(&self) -> bool {
         matches!(&self, ErrCollisionsError::CollidingError(_))
-+
+    }
     /// Returns `true` if the error kind is `ErrCollisionsError::CollidingException`.
     pub fn is_colliding_exception(&self) -> bool {
         matches!(&self, ErrCollisionsError::CollidingException(_))
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ErrCollisionsError::CollidingError(_inner) => _inner.name(),
             ErrCollisionsError::CollidingException(_inner) => _inner.name(),
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for ErrCollisionsError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ErrCollisionsError::CollidingError(_inner) => Some(_inner),
             ErrCollisionsError::CollidingException(_inner) => Some(_inner),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::CollidingError> for crate::error::ErrCollisionsError {
     fn from(variant: crate::error::CollidingError) -> crate::error::ErrCollisionsError {
         Self::CollidingError(variant)
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::CollidingException> for crate::error::ErrCollisionsError {
     fn from(variant: crate::error::CollidingException) -> crate::error::ErrCollisionsError {
         Self::CollidingException(variant)
-+
+    }
-+
+}
-+
 /// This will be renamed to CollidingError
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct CollidingException {}
 impl CollidingException {
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "CollidingException"
-+
+    }
-+
+}
 impl ::std::fmt::Display for CollidingException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "CollidingException")?;
         Ok(())
-+
+    }
-+
+}
 impl ::std::error::Error for CollidingException {}
 impl CollidingException {
     /// Creates a new builder-style object to manufacture [`CollidingException`](crate::error::CollidingException).
     pub fn builder() -> crate::error::colliding_exception::Builder {
         crate::error::colliding_exception::Builder::default()
-+
+    }
-+
+}
-+
 #[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 CollidingError {}
 impl CollidingError {
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "CollidingError"
-+
+    }
-+
+}
 impl ::std::fmt::Display for CollidingError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "CollidingError")?;
         Ok(())
-+
+    }
-+
+}
 impl ::std::error::Error for CollidingError {}
 impl CollidingError {
     /// Creates a new builder-style object to manufacture [`CollidingError`](crate::error::CollidingError).
     pub fn builder() -> crate::error::colliding_error::Builder {
         crate::error::colliding_error::Builder::default()
-+
+    }
-+
+}
-+
 /// Error type for the `ReservedWordsAsMembers` operation.
 /// Each variant represents an error that can occur for the `ReservedWordsAsMembers` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ReservedWordsAsMembersError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationException(crate::error::ValidationException),
-+
+}
 impl ::std::fmt::Display for ReservedWordsAsMembersError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ReservedWordsAsMembersError::ValidationException(_inner) => _inner.fmt(f),
-+
+        }
-+
+    }
-+
+}
 impl ReservedWordsAsMembersError {
     /// Returns `true` if the error kind is `ReservedWordsAsMembersError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(&self, ReservedWordsAsMembersError::ValidationException(_))
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ReservedWordsAsMembersError::ValidationException(_inner) => _inner.name(),
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for ReservedWordsAsMembersError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ReservedWordsAsMembersError::ValidationException(_inner) => Some(_inner),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::ReservedWordsAsMembersError
-+
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::ReservedWordsAsMembersError {
         Self::ValidationException(variant)
-+
+    }
-+
+}
 /// See [`ValidationException`](crate::error::ValidationException).
 pub mod validation_exception {
-+
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `ValidationException`.
         MissingMessage,
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ValidationException`](crate::error::ValidationException).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
         pub(crate) field_list:
             ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
-+
+    }
     impl Builder {
         /// A summary of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-+
+        }
         /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
         pub fn field_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
         ) -> Self {
             self.field_list = input;
             self
-+
+        }
         /// Consumes the builder and constructs a [`ValidationException`](crate::error::ValidationException).
         ///
         /// The builder fails to construct a [`ValidationException`](crate::error::ValidationException) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::error::ValidationException, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::error::ValidationException, ConstraintViolation> {
             Ok(crate::error::ValidationException {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
                 field_list: self.field_list,
             })
-+
+        }
-+
+    }
-+
+}
 /// See [`CollidingException`](crate::error::CollidingException).
 pub mod colliding_exception {
-+
     impl ::std::convert::From<Builder> for crate::error::CollidingException {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`CollidingException`](crate::error::CollidingException).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`CollidingException`](crate::error::CollidingException).
         pub fn build(self) -> crate::error::CollidingException {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::error::CollidingException {
             crate::error::CollidingException {}
-+
+        }
-+
+    }
-+
+}
 /// See [`CollidingError`](crate::error::CollidingError).
 pub mod colliding_error {
-+
     impl ::std::convert::From<Builder> for crate::error::CollidingError {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`CollidingError`](crate::error::CollidingError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`CollidingError`](crate::error::CollidingError).
         pub fn build(self) -> crate::error::CollidingError {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::error::CollidingError {
             crate::error::CollidingError {}
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/naming_test_ops-http0x/rust-server-codegen/src/input.rs

@@ -0,1 +0,1136 @@

 // 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 RpcEchoInput {
     #[allow(missing_docs)] // documentation missing in model
     pub r#as: ::std::option::Option<i32>,
     #[allow(missing_docs)] // documentation missing in model
     pub r#async: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub r#enum: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
     #[allow(missing_docs)] // documentation missing in model
     pub self_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub crate_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub super_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub build_value: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub default_value: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub send: ::std::option::Option<::std::string::String>,
-+
+}
 impl RpcEchoInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#as(&self) -> ::std::option::Option<i32> {
         self.r#as
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#async(&self) -> ::std::option::Option<bool> {
         self.r#async
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#enum(&self) -> ::std::option::Option<&crate::model::UnknownVariantCollidingEnum> {
         self.r#enum.as_ref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn self_(&self) -> ::std::option::Option<bool> {
         self.self_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn crate_(&self) -> ::std::option::Option<bool> {
         self.crate_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn super_(&self) -> ::std::option::Option<bool> {
         self.super_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn build_value(&self) -> ::std::option::Option<&str> {
         self.build_value.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn default_value(&self) -> ::std::option::Option<&str> {
         self.default_value.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn send(&self) -> ::std::option::Option<&str> {
         self.send.as_deref()
-+
+    }
-+
+}
 impl RpcEchoInput {
     /// Creates a new builder-style object to manufacture [`RpcEchoInput`](crate::input::RpcEchoInput).
     pub fn builder() -> crate::input::rpc_echo_input::Builder {
         crate::input::rpc_echo_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::RpcEchoInput {
     type Unconstrained = crate::input::rpc_echo_input::Builder;
-+
+}
-+
 #[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 MatchInput {
     #[allow(missing_docs)] // documentation missing in model
     pub r#as: ::std::option::Option<i32>,
     #[allow(missing_docs)] // documentation missing in model
     pub r#async: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub r#enum: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
     #[allow(missing_docs)] // documentation missing in model
     pub self_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub crate_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub super_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub build_value: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub default_value: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub send: ::std::option::Option<::std::string::String>,
-+
+}
 impl MatchInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#as(&self) -> ::std::option::Option<i32> {
         self.r#as
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#async(&self) -> ::std::option::Option<bool> {
         self.r#async
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#enum(&self) -> ::std::option::Option<&crate::model::UnknownVariantCollidingEnum> {
         self.r#enum.as_ref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn self_(&self) -> ::std::option::Option<bool> {
         self.self_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn crate_(&self) -> ::std::option::Option<bool> {
         self.crate_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn super_(&self) -> ::std::option::Option<bool> {
         self.super_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn build_value(&self) -> ::std::option::Option<&str> {
         self.build_value.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn default_value(&self) -> ::std::option::Option<&str> {
         self.default_value.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn send(&self) -> ::std::option::Option<&str> {
         self.send.as_deref()
-+
+    }
-+
+}
 impl MatchInput {
     /// Creates a new builder-style object to manufacture [`MatchInput`](crate::input::MatchInput).
     pub fn builder() -> crate::input::match_input::Builder {
         crate::input::match_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::MatchInput {
     type Unconstrained = crate::input::match_input::Builder;
-+
+}
-+
 #[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 OptionInput {
     #[allow(missing_docs)] // documentation missing in model
     pub pv_member: ::std::option::Option<bool>,
-+
+}
 impl OptionInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn pv_member(&self) -> ::std::option::Option<bool> {
         self.pv_member
-+
+    }
-+
+}
 impl OptionInput {
     /// Creates a new builder-style object to manufacture [`OptionInput`](crate::input::OptionInput).
     pub fn builder() -> crate::input::option_input::Builder {
         crate::input::option_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::OptionInput {
     type Unconstrained = crate::input::option_input::Builder;
-+
+}
-+
 #[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 ResultInput {
     #[allow(missing_docs)] // documentation missing in model
     pub pv_member: ::std::option::Option<bool>,
-+
+}
 impl ResultInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn pv_member(&self) -> ::std::option::Option<bool> {
         self.pv_member
-+
+    }
-+
+}
 impl ResultInput {
     /// Creates a new builder-style object to manufacture [`ResultInput`](crate::input::ResultInput).
     pub fn builder() -> crate::input::result_input::Builder {
         crate::input::result_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::ResultInput {
     type Unconstrained = crate::input::result_input::Builder;
-+
+}
-+
 #[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 ErrCollisionsInput {}
 impl ErrCollisionsInput {
     /// Creates a new builder-style object to manufacture [`ErrCollisionsInput`](crate::input::ErrCollisionsInput).
     pub fn builder() -> crate::input::err_collisions_input::Builder {
         crate::input::err_collisions_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::ErrCollisionsInput {
     type Unconstrained = crate::input::err_collisions_input::Builder;
-+
+}
-+
 #[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 StructureNamePunningInput {
     #[allow(missing_docs)] // documentation missing in model
     pub regular_string: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub punned_vec: ::std::option::Option<crate::model::Vec>,
-+
+}
 impl StructureNamePunningInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn regular_string(&self) -> ::std::option::Option<&str> {
         self.regular_string.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn punned_vec(&self) -> ::std::option::Option<&crate::model::Vec> {
         self.punned_vec.as_ref()
-+
+    }
-+
+}
 impl StructureNamePunningInput {
     /// Creates a new builder-style object to manufacture [`StructureNamePunningInput`](crate::input::StructureNamePunningInput).
     pub fn builder() -> crate::input::structure_name_punning_input::Builder {
         crate::input::structure_name_punning_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::StructureNamePunningInput {
     type Unconstrained = crate::input::structure_name_punning_input::Builder;
-+
+}
-+
 #[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 ReservedWordsAsMembersInput {
     #[allow(missing_docs)] // documentation missing in model
     pub r#as: ::std::option::Option<i32>,
     #[allow(missing_docs)] // documentation missing in model
     pub r#async: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub r#enum: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
     #[allow(missing_docs)] // documentation missing in model
     pub self_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub crate_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub super_: ::std::option::Option<bool>,
     #[allow(missing_docs)] // documentation missing in model
     pub build_value: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub default_value: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub send: ::std::option::Option<::std::string::String>,
-+
+}
 impl ReservedWordsAsMembersInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#as(&self) -> ::std::option::Option<i32> {
         self.r#as
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#async(&self) -> ::std::option::Option<bool> {
         self.r#async
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn r#enum(&self) -> ::std::option::Option<&crate::model::UnknownVariantCollidingEnum> {
         self.r#enum.as_ref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn self_(&self) -> ::std::option::Option<bool> {
         self.self_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn crate_(&self) -> ::std::option::Option<bool> {
         self.crate_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn super_(&self) -> ::std::option::Option<bool> {
         self.super_
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn build_value(&self) -> ::std::option::Option<&str> {
         self.build_value.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn default_value(&self) -> ::std::option::Option<&str> {
         self.default_value.as_deref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn send(&self) -> ::std::option::Option<&str> {
         self.send.as_deref()
-+
+    }
-+
+}
 impl ReservedWordsAsMembersInput {
     /// Creates a new builder-style object to manufacture [`ReservedWordsAsMembersInput`](crate::input::ReservedWordsAsMembersInput).
     pub fn builder() -> crate::input::reserved_words_as_members_input::Builder {
         crate::input::reserved_words_as_members_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::ReservedWordsAsMembersInput {
     type Unconstrained = crate::input::reserved_words_as_members_input::Builder;
-+
+}
 /// See [`RpcEchoInput`](crate::input::RpcEchoInput).
 pub mod rpc_echo_input {
-+
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// Constraint violation occurred building member `r#enum` when building `RpcEchoInput`.
         #[doc(hidden)]
         Enum(crate::model::unknown_variant_colliding_enum::ConstraintViolation),
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `RpcEchoInput`"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Enum(inner) => {
                     inner.as_validation_exception_field(path + "/enum")
-+
+                }
-+
+            }
-+
+        }
-+
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_legacy_http_server::protocol::aws_json::rejection::RequestRejection
-+
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),
             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-+
+                            )
-+
+        }
-+
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::RpcEchoInput>
-+
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-+
+        }
-+
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::RpcEchoInput {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`RpcEchoInput`](crate::input::RpcEchoInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) r#as: ::std::option::Option<i32>,
         pub(crate) r#async: ::std::option::Option<bool>,
         pub(crate) r#enum: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
         >,
         pub(crate) self_: ::std::option::Option<bool>,
         pub(crate) crate_: ::std::option::Option<bool>,
         pub(crate) super_: ::std::option::Option<bool>,
         pub(crate) build_value: ::std::option::Option<::std::string::String>,
         pub(crate) default_value: ::std::option::Option<::std::string::String>,
         pub(crate) send: ::std::option::Option<::std::string::String>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#as(mut self, input: ::std::option::Option<i32>) -> Self {
             self.r#as = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_as(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.r#as = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#async(mut self, input: ::std::option::Option<bool>) -> Self {
             self.r#async = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_async(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.r#async = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
         ) -> Self {
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
                 >,
             >,
         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn self_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.self_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_self(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.self_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn crate_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.crate_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_crate(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.crate_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn super_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.super_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_super(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.super_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn build_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.build_value = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_build(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.build_value = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn default_value(
             mut self,
             input: ::std::option::Option<::std::string::String>,
         ) -> Self {
             self.default_value = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_default(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.default_value = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn send(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.send = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_send(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.send = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`RpcEchoInput`](crate::input::RpcEchoInput).
         ///
         /// The builder fails to construct a [`RpcEchoInput`](crate::input::RpcEchoInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::RpcEchoInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::RpcEchoInput, ConstraintViolation> {
             Ok(crate::input::RpcEchoInput {
                 r#as: self.r#as,
                 r#async: self.r#async,
                 r#enum: self
                     .r#enum
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Enum))
                     .transpose()?,
                 self_: self.self_,
                 crate_: self.crate_,
                 super_: self.super_,
                 build_value: self.build_value,
                 default_value: self.default_value,
                 send: self.send,
             })
-+
+        }
-+
+    }
-+
+}
 /// See [`MatchInput`](crate::input::MatchInput).
 pub mod match_input {
-+
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// Constraint violation occurred building member `r#enum` when building `MatchInput`.
         #[doc(hidden)]
         Enum(crate::model::unknown_variant_colliding_enum::ConstraintViolation),
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `MatchInput`"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Enum(inner) => {
                     inner.as_validation_exception_field(path + "/enum")
-+
+                }
-+
+            }
-+
+        }
-+
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_legacy_http_server::protocol::aws_json::rejection::RequestRejection
-+
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),
             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-+
+                            )
-+
+        }
-+
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MatchInput>
-+
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-+
+        }
-+
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MatchInput {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`MatchInput`](crate::input::MatchInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) r#as: ::std::option::Option<i32>,
         pub(crate) r#async: ::std::option::Option<bool>,
         pub(crate) r#enum: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
         >,
         pub(crate) self_: ::std::option::Option<bool>,
         pub(crate) crate_: ::std::option::Option<bool>,
         pub(crate) super_: ::std::option::Option<bool>,
         pub(crate) build_value: ::std::option::Option<::std::string::String>,
         pub(crate) default_value: ::std::option::Option<::std::string::String>,
         pub(crate) send: ::std::option::Option<::std::string::String>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#as(mut self, input: ::std::option::Option<i32>) -> Self {
             self.r#as = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_as(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.r#as = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#async(mut self, input: ::std::option::Option<bool>) -> Self {
             self.r#async = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_async(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.r#async = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
         ) -> Self {
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
                 >,
             >,
         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn self_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.self_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_self(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.self_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn crate_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.crate_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_crate(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.crate_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn super_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.super_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_super(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.super_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn build_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.build_value = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_build(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.build_value = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn default_value(
             mut self,
             input: ::std::option::Option<::std::string::String>,
         ) -> Self {
             self.default_value = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_default(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.default_value = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn send(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.send = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_send(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.send = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`MatchInput`](crate::input::MatchInput).
         ///
         /// The builder fails to construct a [`MatchInput`](crate::input::MatchInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::MatchInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::MatchInput, ConstraintViolation> {
             Ok(crate::input::MatchInput {
                 r#as: self.r#as,
                 r#async: self.r#async,
                 r#enum: self
                     .r#enum
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Enum))
                     .transpose()?,
                 self_: self.self_,
                 crate_: self.crate_,
                 super_: self.super_,
                 build_value: self.build_value,
                 default_value: self.default_value,
                 send: self.send,
             })
-+
+        }
-+
+    }
-+
+}
 /// See [`OptionInput`](crate::input::OptionInput).
 pub mod option_input {
-+
     impl ::std::convert::From<Builder> for crate::input::OptionInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`OptionInput`](crate::input::OptionInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) pv_member: ::std::option::Option<bool>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn pv_member(mut self, input: ::std::option::Option<bool>) -> Self {
             self.pv_member = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_pv_member(
             mut self,
             input: Option<impl ::std::convert::Into<bool>>,
         ) -> Self {
             self.pv_member = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`OptionInput`](crate::input::OptionInput).
         pub fn build(self) -> crate::input::OptionInput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::OptionInput {
             crate::input::OptionInput {
                 pv_member: self.pv_member,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`ResultInput`](crate::input::ResultInput).
 pub mod result_input {
-+
     impl ::std::convert::From<Builder> for crate::input::ResultInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ResultInput`](crate::input::ResultInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) pv_member: ::std::option::Option<bool>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn pv_member(mut self, input: ::std::option::Option<bool>) -> Self {
             self.pv_member = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_pv_member(
             mut self,
             input: Option<impl ::std::convert::Into<bool>>,
         ) -> Self {
             self.pv_member = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`ResultInput`](crate::input::ResultInput).
         pub fn build(self) -> crate::input::ResultInput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::ResultInput {
             crate::input::ResultInput {
                 pv_member: self.pv_member,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`ErrCollisionsInput`](crate::input::ErrCollisionsInput).
 pub mod err_collisions_input {
-+
     impl ::std::convert::From<Builder> for crate::input::ErrCollisionsInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ErrCollisionsInput`](crate::input::ErrCollisionsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`ErrCollisionsInput`](crate::input::ErrCollisionsInput).
         pub fn build(self) -> crate::input::ErrCollisionsInput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::ErrCollisionsInput {
             crate::input::ErrCollisionsInput {}
-+
+        }
-+
+    }
-+
+}
 /// See [`StructureNamePunningInput`](crate::input::StructureNamePunningInput).
 pub mod structure_name_punning_input {
-+
     impl ::std::convert::From<Builder> for crate::input::StructureNamePunningInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`StructureNamePunningInput`](crate::input::StructureNamePunningInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) regular_string: ::std::option::Option<::std::string::String>,
         pub(crate) punned_vec: ::std::option::Option<crate::model::Vec>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn regular_string(
             mut self,
             input: ::std::option::Option<::std::string::String>,
         ) -> Self {
             self.regular_string = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_regular_string(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.regular_string = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn punned_vec(mut self, input: ::std::option::Option<crate::model::Vec>) -> Self {
             self.punned_vec = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_punned_vec(
             mut self,
             input: Option<impl ::std::convert::Into<crate::model::Vec>>,
         ) -> Self {
             self.punned_vec = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`StructureNamePunningInput`](crate::input::StructureNamePunningInput).
         pub fn build(self) -> crate::input::StructureNamePunningInput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::StructureNamePunningInput {
             crate::input::StructureNamePunningInput {
                 regular_string: self.regular_string,
                 punned_vec: self.punned_vec,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`ReservedWordsAsMembersInput`](crate::input::ReservedWordsAsMembersInput).
 pub mod reserved_words_as_members_input {
-+
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// Constraint violation occurred building member `r#enum` when building `ReservedWordsAsMembersInput`.
         #[doc(hidden)]
         Enum(crate::model::unknown_variant_colliding_enum::ConstraintViolation),
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `ReservedWordsAsMembersInput`"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Enum(inner) => {
                     inner.as_validation_exception_field(path + "/enum")
-+
+                }
-+
+            }
-+
+        }
-+
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_legacy_http_server::protocol::aws_json::rejection::RequestRejection
-+
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),
             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-+
+                            )
-+
+        }
-+
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::ReservedWordsAsMembersInput>
-+
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-+
+        }
-+
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::ReservedWordsAsMembersInput {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ReservedWordsAsMembersInput`](crate::input::ReservedWordsAsMembersInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) r#as: ::std::option::Option<i32>,
         pub(crate) r#async: ::std::option::Option<bool>,
         pub(crate) r#enum: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
         >,
         pub(crate) self_: ::std::option::Option<bool>,
         pub(crate) crate_: ::std::option::Option<bool>,
         pub(crate) super_: ::std::option::Option<bool>,
         pub(crate) build_value: ::std::option::Option<::std::string::String>,
         pub(crate) default_value: ::std::option::Option<::std::string::String>,
         pub(crate) send: ::std::option::Option<::std::string::String>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#as(mut self, input: ::std::option::Option<i32>) -> Self {
             self.r#as = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_as(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.r#as = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#async(mut self, input: ::std::option::Option<bool>) -> Self {
             self.r#async = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_async(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.r#async = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
         ) -> Self {
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
                 >,
             >,
         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn self_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.self_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_self(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.self_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn crate_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.crate_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_crate(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.crate_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn super_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.super_ = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_super(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.super_ = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn build_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.build_value = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_build(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.build_value = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn default_value(
             mut self,
             input: ::std::option::Option<::std::string::String>,
         ) -> Self {
             self.default_value = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_default(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.default_value = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn send(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.send = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_send(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.send = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`ReservedWordsAsMembersInput`](crate::input::ReservedWordsAsMembersInput).
         ///
         /// The builder fails to construct a [`ReservedWordsAsMembersInput`](crate::input::ReservedWordsAsMembersInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::input::ReservedWordsAsMembersInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::ReservedWordsAsMembersInput, ConstraintViolation> {
             Ok(crate::input::ReservedWordsAsMembersInput {
                 r#as: self.r#as,
                 r#async: self.r#async,
                 r#enum: self
                     .r#enum
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Enum))
                     .transpose()?,
                 self_: self.self_,
                 crate_: self.crate_,
                 super_: self.super_,
                 build_value: self.build_value,
                 default_value: self.default_value,
                 send: self.send,
             })
-+
+        }
-+
+    }
-+
+}

 // 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;

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

-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#awsJson1_1"
 [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-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.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.mime]
 version = "0.3"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.hyper]
 version = "0.14.12"
 version = "1"
 [dev-dependencies.tokio]
 version = "1.23.1"
 [features]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 default = ["rt-tokio", "request-id"]
-44
-45

     type Output = Result<
         crate::input::DoNothingInput,
         ::aws_smithy_http_server::protocol::aws_json::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::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::DoNothingInput
 where

     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-37
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = DoNothingInputFuture;
-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_X_AMZ_JSON_1_1,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-48
+            }
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;

Server Test

Files changed:

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

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

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

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

tmp-codegen-diff/codegen-server-test/naming_test_casing/rust-server-codegen/src/protocol_serde/shape_do_nothing.rs

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

tmp-codegen-diff/codegen-server-test/naming_test_ops-http0x/rust-server-codegen/Cargo.toml

tmp-codegen-diff/codegen-server-test/naming_test_ops-http0x/rust-server-codegen/src/constrained.rs

tmp-codegen-diff/codegen-server-test/naming_test_ops-http0x/rust-server-codegen/src/error.rs

tmp-codegen-diff/codegen-server-test/naming_test_ops-http0x/rust-server-codegen/src/input.rs

         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         DoNothingInputFuture {
             inner: Box::pin(fut),
-60
+        }
-61
+    }
-62
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::DoNothingOutput
-67
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_response(self) {
             Ok(response) => response,
             Err(e) => {

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_do_nothing_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::DoNothingInput,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::do_nothing_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();
         input.build()
     })
-24
+}
-25
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_do_nothing_http_response(
     #[allow(unused_variables)] output: crate::output::DoNothingOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::aws_json::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/x-amz-json-1.1",
         );
         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)?
     })
-53
+}

     /// # let app: AcronymInsideService<::aws_smithy_http_server::routing::RoutingService<::aws_smithy_http_server::protocol::aws_json::router::AwsJsonRouter<::aws_smithy_http_server::routing::Route>, ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>> = app;
     /// ```
     ///
                     pub fn do_nothing<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self
                     where
                         HandlerType: ::aws_smithy_http_server::operation::Handler<crate::operation_shape::DoNothing, HandlerExtractors>,
-41
                         ModelPl: ::aws_smithy_http_server::plugin::Plugin<
                             AcronymInsideService<L>,
                             crate::operation_shape::DoNothing,
                             ::aws_smithy_http_server::operation::IntoService<crate::operation_shape::DoNothing, HandlerType>
                         >,
                         ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<
                             AcronymInsideService<L>,
                             crate::operation_shape::DoNothing,
                             ModelPl::Output
                         >,
                         HttpPl: ::aws_smithy_http_server::plugin::Plugin<
                             AcronymInsideService<L>,
                             crate::operation_shape::DoNothing,

-55
+                            <
                                 ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
                                 as ::aws_smithy_http_server::plugin::Plugin<
                                     AcronymInsideService<L>,
                                     crate::operation_shape::DoNothing,
                                     ModelPl::Output
-61
+                                >
                             >::Output
                         >,
-64
                         HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
                         HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
                         <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
-67
-68
+                    {
         use ::aws_smithy_http_server::operation::OperationShapeExt;
         use ::aws_smithy_http_server::plugin::Plugin;
         let svc = crate::operation_shape::DoNothing::from_handler(handler);
         let svc = self.model_plugin.apply(svc);
         let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
             .apply(svc);
         let svc = self.http_plugin.apply(svc);
         self.do_nothing_custom(svc)

-77
+    }
-78
     /// Sets the [`DoNothing`](crate::operation_shape::DoNothing) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use naming_test_casing::{AcronymInsideService, AcronymInsideServiceConfig};
     ///
     /// use naming_test_casing::{input, output};
     ///
     /// async fn handler(input: input::DoNothingInput) -> Result<output::DoNothingOutput, std::convert::Infallible> {
     ///     todo!()
     /// }
     ///
     /// let config = AcronymInsideServiceConfig::builder().build();
     /// let svc = ::tower::util::service_fn(handler);

         layer: &L,
     ) -> AcronymInsideService<
         ::aws_smithy_http_server::routing::RoutingService<
             ::aws_smithy_http_server::protocol::aws_json::router::AwsJsonRouter<L::Service>,
             ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         >,
-399
+    >
     where
         L: ::tower::Layer<S>,
-402
+    {
         AcronymInsideService {
             svc: self.svc.map(|s| s.layer(layer)),
-405
+        }
-406
+    }
-407
     /// Applies [`Route::new`](::aws_smithy_http_server::routing::Route::new) to all routes.
     ///
     /// This has the effect of erasing all types accumulated via layers.
     pub fn boxed<B>(
         self,

-435
 impl<S, R> ::tower::Service<R> for AcronymInsideService<S>
 where
     S: ::tower::Service<R>,
-439
+{
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
-443
     fn poll_ready(
         &mut self,
         cx: &mut std::task::Context,
     ) -> std::task::Poll<::std::result::Result<(), Self::Error>> {
         self.svc.poll_ready(cx)
-449
+    }
-450
     fn call(&mut self, request: R) -> Self::Future {
         self.svc.call(request)
-453
+    }
-454
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 pub(crate) trait Constrained {
     type Unconstrained;
-+
+}
-+
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub(crate) enum MaybeConstrained<T: Constrained> {
     Constrained(T),
     Unconstrained(T::Unconstrained),
-+
+}