Server Test

rev. a7fb2e3446d314cfbe48069306e4e0a389b39aeb (ignoring whitespace)

Files changed:

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

@@ -457,457 +516,572 @@

 pub(crate) mod map_of_length_string_constrained {
-458
     #[derive(Debug, Clone)]
     pub(crate) struct MapOfLengthStringConstrained(
         pub(crate) std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
     );
-463
     impl crate::constrained::Constrained for MapOfLengthStringConstrained {
         type Unconstrained = crate::unconstrained::map_of_length_string_unconstrained::MapOfLengthStringUnconstrained;
-466
+    }
     impl
         ::std::convert::From<
             ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
         > for MapOfLengthStringConstrained
-471
+    {
         fn from(
             v: ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
         ) -> Self {
             Self(v)
-476
+        }

-477
+    }
-478
     impl ::std::convert::From<MapOfLengthStringConstrained>
         for ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>
-481
+    {
         fn from(v: MapOfLengthStringConstrained) -> Self {
             v.0
-484
+        }
-485
+    }
-486
+}
 pub(crate) mod indirectly_constrained_map_constrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct IndirectlyConstrainedMapConstrained(
         pub(crate) std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
     );
-+
     impl crate::constrained::Constrained for IndirectlyConstrainedMapConstrained {
         type Unconstrained = crate::unconstrained::indirectly_constrained_map_unconstrained::IndirectlyConstrainedMapUnconstrained;
-+
+    }
     impl
         ::std::convert::From<
             ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
         > for IndirectlyConstrainedMapConstrained
-+
+    {
         fn from(
             v: ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
         ) -> Self {
             Self(v)
-+
+        }
-+
+    }
-+
     impl ::std::convert::From<IndirectlyConstrainedMapConstrained>
         for ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>
-+
+    {
         fn from(v: IndirectlyConstrainedMapConstrained) -> Self {
             v.0
-+
+        }
-+
+    }
-+
+}
 pub(crate) mod indirectly_constrained_list_constrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct IndirectlyConstrainedListConstrained(
         pub(crate) std::vec::Vec<crate::model::LengthString>,
     );
-+
     impl crate::constrained::Constrained for IndirectlyConstrainedListConstrained {
         type Unconstrained = crate::unconstrained::indirectly_constrained_list_unconstrained::IndirectlyConstrainedListUnconstrained;
-+
+    }
     impl ::std::convert::From<::std::vec::Vec<crate::model::LengthString>>
         for IndirectlyConstrainedListConstrained
-+
+    {
         fn from(v: ::std::vec::Vec<crate::model::LengthString>) -> Self {
             Self(v)
-+
+        }
-+
+    }
-+
     impl ::std::convert::From<IndirectlyConstrainedListConstrained>
         for ::std::vec::Vec<crate::model::LengthString>
-+
+    {
         fn from(v: IndirectlyConstrainedListConstrained) -> Self {
             v.0
-+
+        }
-+
+    }
-+
+}
 pub(crate) mod recursive_list_constrained {
-544
     #[derive(Debug, Clone)]
     pub(crate) struct RecursiveListConstrained(
         pub(crate) std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
     );
-549
     impl crate::constrained::Constrained for RecursiveListConstrained {
         type Unconstrained =
             crate::unconstrained::recursive_list_unconstrained::RecursiveListUnconstrained;

↧ Expand context

-553
+    }
     impl ::std::convert::From<::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>>
         for RecursiveListConstrained
-556
+    {
         fn from(v: ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>) -> Self {
             Self(v)
-559
+        }
-560
+    }
-561
     impl ::std::convert::From<RecursiveListConstrained>
         for ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>
-564
+    {
         fn from(v: RecursiveListConstrained) -> Self {
             v.0
-567
+        }
-568
+    }
-569
+}
 pub(crate) mod map_of_range_byte_constrained {
-571
     #[derive(Debug, Clone)]

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

@@ -785,785 +844,896 @@

↥ Expand context

-785
+        )
-786
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             QueryParamsTargetingLengthMapOperationError::ValidationException(_inner) => {
                 _inner.name()
-792
+            }
-793
+        }
-794
+    }
-795
+}
 impl ::std::error::Error for QueryParamsTargetingLengthMapOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             QueryParamsTargetingLengthMapOperationError::ValidationException(_inner) => {
                 Some(_inner)
-801
+            }
-802
+        }
-803
+    }
-804
+}

 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::QueryParamsTargetingLengthMapOperationError
-807
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::QueryParamsTargetingLengthMapOperationError {
         Self::ValidationException(variant)
-812
+    }
-813
+}
-814
 /// Error type for the `ConstrainedListWithIndirectlyConstrainedAggregateOperation` operation.
 /// Each variant represents an error that can occur for the `ConstrainedListWithIndirectlyConstrainedAggregateOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ConstrainedListWithIndirectlyConstrainedAggregateOperationError {
     /// 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 ConstrainedListWithIndirectlyConstrainedAggregateOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ConstrainedListWithIndirectlyConstrainedAggregateOperationError::ValidationException(_inner) =>
             _inner.fmt(f)
-+
+            ,
-+
+        }
-+
+    }
-+
+}
 impl ConstrainedListWithIndirectlyConstrainedAggregateOperationError {
     /// Returns `true` if the error kind is `ConstrainedListWithIndirectlyConstrainedAggregateOperationError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(
             &self,
             ConstrainedListWithIndirectlyConstrainedAggregateOperationError::ValidationException(_)
-+
+        )
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ConstrainedListWithIndirectlyConstrainedAggregateOperationError::ValidationException(_inner) =>
             _inner.name()
-+
+            ,
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for ConstrainedListWithIndirectlyConstrainedAggregateOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ConstrainedListWithIndirectlyConstrainedAggregateOperationError::ValidationException(_inner) =>
             Some(_inner)
-+
+            ,
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError
-+
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError {
         Self::ValidationException(variant)
-+
+    }
-+
+}
-+
 /// Error type for the `ConstrainedRecursiveShapesOperation` operation.
 /// Each variant represents an error that can occur for the `ConstrainedRecursiveShapesOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ConstrainedRecursiveShapesOperationError {
     /// 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),
-873
+}
 impl ::std::fmt::Display for ConstrainedRecursiveShapesOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {

↧ Expand context

             ConstrainedRecursiveShapesOperationError::ValidationException(_inner) => _inner.fmt(f),
-878
+        }
-879
+    }
-880
+}
 impl ConstrainedRecursiveShapesOperationError {
     /// Returns `true` if the error kind is `ConstrainedRecursiveShapesOperationError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(
             &self,
             ConstrainedRecursiveShapesOperationError::ValidationException(_)
-887
+        )
-888
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ConstrainedRecursiveShapesOperationError::ValidationException(_inner) => _inner.name(),
-893
+        }
-894
+    }
-895
+}
 impl ::std::error::Error for ConstrainedRecursiveShapesOperationError {

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

@@ -451,451 +510,542 @@

↥ Expand context

-451
+}
 impl crate::constrained::Constrained
     for crate::input::QueryParamsTargetingMapOfLengthStringOperationInput
-454
+{
     type Unconstrained =
         crate::input::query_params_targeting_map_of_length_string_operation_input::Builder;
-457
+}
-458
 #[allow(missing_docs)] // documentation missing in model
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct QueryParamsTargetingLengthMapOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub length_map: ::std::option::Option<crate::model::ConBMap>,
-464
+}
 impl QueryParamsTargetingLengthMapOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn length_map(&self) -> ::std::option::Option<&crate::model::ConBMap> {
         self.length_map.as_ref()
-469
+    }
-470
+}

 impl QueryParamsTargetingLengthMapOperationInput {
     /// Creates a new builder-style object to manufacture [`QueryParamsTargetingLengthMapOperationInput`](crate::input::QueryParamsTargetingLengthMapOperationInput).
     pub fn builder() -> crate::input::query_params_targeting_length_map_operation_input::Builder {
         crate::input::query_params_targeting_length_map_operation_input::Builder::default()
-475
+    }
-476
+}
 impl crate::constrained::Constrained for crate::input::QueryParamsTargetingLengthMapOperationInput {
     type Unconstrained = crate::input::query_params_targeting_length_map_operation_input::Builder;
-479
+}
-480
 #[allow(missing_docs)] // documentation missing in model
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub a: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedList>,
     #[allow(missing_docs)] // documentation missing in model
     pub b: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedMap>,
-+
+}
 impl ConstrainedListWithIndirectlyConstrainedAggregateOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn a(&self) -> ::std::option::Option<&crate::model::ListWithIndirectlyConstrainedList> {
         self.a.as_ref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn b(&self) -> ::std::option::Option<&crate::model::ListWithIndirectlyConstrainedMap> {
         self.b.as_ref()
-+
+    }
-+
+}
 impl ConstrainedListWithIndirectlyConstrainedAggregateOperationInput {
     /// Creates a new builder-style object to manufacture [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput).
     pub fn builder(
     ) -> crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input::Builder
-+
+    {
         crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input::Builder::default()
-+
+    }
-+
+}
 impl crate::constrained::Constrained
     for crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput
-+
+{
     type Unconstrained = crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_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 ConstrainedRecursiveShapesOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub nested: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,
     #[allow(missing_docs)] // documentation missing in model
     pub recursive_list: ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
-522
+}

↧ Expand context

 impl ConstrainedRecursiveShapesOperationInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(
         &self,
     ) -> ::std::option::Option<&crate::model::RecursiveShapesInputOutputNested1> {
         self.nested.as_ref()
-529
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn recursive_list(&self) -> &[crate::model::RecursiveShapesInputOutputNested1] {
         use std::ops::Deref;
         self.recursive_list.deref()
-534
+    }
-535
+}
 impl ConstrainedRecursiveShapesOperationInput {
     /// Creates a new builder-style object to manufacture [`ConstrainedRecursiveShapesOperationInput`](crate::input::ConstrainedRecursiveShapesOperationInput).
     pub fn builder() -> crate::input::constrained_recursive_shapes_operation_input::Builder {
         crate::input::constrained_recursive_shapes_operation_input::Builder::default()
-540
+    }
-541
+}
 impl crate::constrained::Constrained for crate::input::ConstrainedRecursiveShapesOperationInput {

@@ -2647,2679 +2706,2913 @@

↥ Expand context

             self.length_map = input.map(|v| v.into());
             self
-2681
+        }
         /// Consumes the builder and constructs a [`QueryParamsTargetingLengthMapOperationInput`](crate::input::QueryParamsTargetingLengthMapOperationInput).
         ///
         /// The builder fails to construct a [`QueryParamsTargetingLengthMapOperationInput`](crate::input::QueryParamsTargetingLengthMapOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::input::QueryParamsTargetingLengthMapOperationInput, ConstraintViolation>
-2689
+        {
             self.build_enforcing_all_constraints()
-2691
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::QueryParamsTargetingLengthMapOperationInput, ConstraintViolation>
-2695
+        {
             Ok(crate::input::QueryParamsTargetingLengthMapOperationInput {
                 length_map: self
                     .length_map

                     .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::LengthMap))
                     .transpose()?,
             })
-2706
+        }
-2707
+    }
-2708
+}
 /// See [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput).
 pub mod constrained_list_with_indirectly_constrained_aggregate_operation_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 `a` when building `ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`.
         #[doc(hidden)]
         A(crate::model::list_with_indirectly_constrained_list::ConstraintViolation),
         /// Constraint violation occurred building member `b` when building `ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`.
         #[doc(hidden)]
         B(crate::model::list_with_indirectly_constrained_map::ConstraintViolation),
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::A(_) => write!(f, "constraint violation occurred building member `a` when building `ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`"),
                 ConstraintViolation::B(_) => write!(f, "constraint violation occurred building member `b` when building `ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`"),
-+
+            }
-+
+        }
-+
+    }
     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::A(inner) => inner.as_validation_exception_field(path + "/a"),
                 ConstraintViolation::B(inner) => inner.as_validation_exception_field(path + "/b"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::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::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
-+
+        >
-+
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-+
+        }
-+
+    }
     impl ::std::convert::TryFrom<Builder>
         for crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput
-+
+    {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) a: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::ListWithIndirectlyConstrainedList>,
         >,
         pub(crate) b: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::ListWithIndirectlyConstrainedMap>,
         >,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn a(
             mut self,
             input: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedList>,
         ) -> Self {
             self.a = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_a(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::model::ListWithIndirectlyConstrainedList,
                     >,
                 >,
             >,
         ) -> Self {
             self.a = input.map(|v| v.into());
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn b(
             mut self,
             input: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedMap>,
         ) -> Self {
             self.b = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_b(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::model::ListWithIndirectlyConstrainedMap,
                     >,
                 >,
             >,
         ) -> Self {
             self.b = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput).
         ///
         /// The builder fails to construct a [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(
             self,
         ) -> Result<
             crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
             ConstraintViolation,
         > {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<
             crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
             ConstraintViolation,
         > {
             Ok(
                 crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput {
                     a: self
                         .a
                         .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::A))
                         .transpose()?,
                     b: self
                         .b
                         .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::B))
                         .transpose()?,
                 },
-+
+            )
-+
+        }
-+
+    }
-+
+}
 /// See [`ConstrainedRecursiveShapesOperationInput`](crate::input::ConstrainedRecursiveShapesOperationInput).
 pub mod constrained_recursive_shapes_operation_input {
-2886
     #[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 `nested` when building `ConstrainedRecursiveShapesOperationInput`.
         #[doc(hidden)]

↧ Expand context

         Nested(crate::model::recursive_shapes_input_output_nested1::ConstraintViolation),
         /// `recursive_list` was not provided but it is required when building `ConstrainedRecursiveShapesOperationInput`.
         MissingRecursiveList,
         /// Constraint violation occurred building member `recursive_list` when building `ConstrainedRecursiveShapesOperationInput`.
         #[doc(hidden)]
         RecursiveList(crate::model::recursive_list::ConstraintViolation),
-2900
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Nested(_) => write!(f, "constraint violation occurred building member `nested` when building `ConstrainedRecursiveShapesOperationInput`"),
                 ConstraintViolation::MissingRecursiveList => write!(f, "`recursive_list` was not provided but it is required when building `ConstrainedRecursiveShapesOperationInput`"),
                 ConstraintViolation::RecursiveList(_) => write!(f, "constraint violation occurred building member `recursive_list` when building `ConstrainedRecursiveShapesOperationInput`"),
-2907
+            }
-2908
+        }
-2909
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

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

@@ -139,139 +240,245 @@

↥ Expand context

 //!     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 [`ConstraintsServiceBuilder`] into [`ConstraintsService`] using either [`ConstraintsServiceBuilder::build`] or [`ConstraintsServiceBuilder::build_unchecked`].
 //!
 //! [`ConstraintsServiceBuilder::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.
 //!
 //! [`ConstraintsServiceBuilder::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.
 //! [`ConstraintsServiceBuilder::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 constraints::{ConstraintsService, ConstraintsServiceConfig};
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = ConstraintsServiceConfig::builder().build();
 //!    let app = ConstraintsService::builder(config)
 //!        .constrained_http_bound_shapes_operation(constrained_http_bound_shapes_operation)
 //!        .constrained_http_payload_bound_shape_operation(constrained_http_payload_bound_shape_operation)
 //!        .constrained_list_with_indirectly_constrained_aggregate_operation(constrained_list_with_indirectly_constrained_aggregate_operation)
 //!        .constrained_recursive_shapes_operation(constrained_recursive_shapes_operation)
 //!        .constrained_shapes_only_in_output_operation(constrained_shapes_only_in_output_operation)
 //!        .constrained_shapes_operation(constrained_shapes_operation)
 //!        .event_streams_operation(event_streams_operation)
 //!        .http_prefix_headers_targeting_length_map_operation(http_prefix_headers_targeting_length_map_operation)
 //!        .non_streaming_blob_operation(non_streaming_blob_operation)
 //!        .query_params_targeting_length_map_operation(query_params_targeting_length_map_operation)
 //!        .query_params_targeting_map_of_enum_string_operation(query_params_targeting_map_of_enum_string_operation)
 //!        .query_params_targeting_map_of_length_list_of_pattern_string_operation(query_params_targeting_map_of_length_list_of_pattern_string_operation)
 //!        .query_params_targeting_map_of_length_pattern_string_operation(query_params_targeting_map_of_length_pattern_string_operation)
 //!        .query_params_targeting_map_of_length_string_operation(query_params_targeting_map_of_length_string_operation)
 //!        .query_params_targeting_map_of_list_of_enum_string_operation(query_params_targeting_map_of_list_of_enum_string_operation)
 //!        .query_params_targeting_map_of_list_of_length_pattern_string_operation(query_params_targeting_map_of_list_of_length_pattern_string_operation)
 //!        .query_params_targeting_map_of_list_of_length_string_operation(query_params_targeting_map_of_list_of_length_string_operation)
 //!        .query_params_targeting_map_of_list_of_pattern_string_operation(query_params_targeting_map_of_list_of_pattern_string_operation)
 //!        .query_params_targeting_map_of_pattern_string_operation(query_params_targeting_map_of_pattern_string_operation)
 //!        .query_params_targeting_map_of_set_of_length_string_operation(query_params_targeting_map_of_set_of_length_string_operation)
 //!        .streaming_blob_operation(streaming_blob_operation)
 //!        .build()
 //!        .expect("failed to build an instance of ConstraintsService");
 //!
 //!    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 server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use constraints::{input, output, error};
 //!
 //! async fn constrained_http_bound_shapes_operation(input: input::ConstrainedHttpBoundShapesOperationInput) -> Result<output::ConstrainedHttpBoundShapesOperationOutput, error::ConstrainedHttpBoundShapesOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn constrained_http_payload_bound_shape_operation(input: input::ConstrainedHttpPayloadBoundShapeOperationInput) -> Result<output::ConstrainedHttpPayloadBoundShapeOperationOutput, error::ConstrainedHttpPayloadBoundShapeOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn constrained_list_with_indirectly_constrained_aggregate_operation(input: input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput) -> Result<output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput, error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn constrained_recursive_shapes_operation(input: input::ConstrainedRecursiveShapesOperationInput) -> Result<output::ConstrainedRecursiveShapesOperationOutput, error::ConstrainedRecursiveShapesOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn constrained_shapes_only_in_output_operation(input: input::ConstrainedShapesOnlyInOutputOperationInput) -> output::ConstrainedShapesOnlyInOutputOperationOutput {
 //!     todo!()
 //! }
 //!
 //! async fn constrained_shapes_operation(input: input::ConstrainedShapesOperationInput) -> Result<output::ConstrainedShapesOperationOutput, error::ConstrainedShapesOperationError> {
 //!     todo!()

↧ Expand context

 //! }
 //!
 //! async fn event_streams_operation(input: input::EventStreamsOperationInput) -> Result<output::EventStreamsOperationOutput, error::EventStreamsOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn http_prefix_headers_targeting_length_map_operation(input: input::HttpPrefixHeadersTargetingLengthMapOperationInput) -> Result<output::HttpPrefixHeadersTargetingLengthMapOperationOutput, error::HttpPrefixHeadersTargetingLengthMapOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn non_streaming_blob_operation(input: input::NonStreamingBlobOperationInput) -> output::NonStreamingBlobOperationOutput {
 //!     todo!()
 //! }
 //!
 //! async fn query_params_targeting_length_map_operation(input: input::QueryParamsTargetingLengthMapOperationInput) -> Result<output::QueryParamsTargetingLengthMapOperationOutput, error::QueryParamsTargetingLengthMapOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn query_params_targeting_map_of_enum_string_operation(input: input::QueryParamsTargetingMapOfEnumStringOperationInput) -> Result<output::QueryParamsTargetingMapOfEnumStringOperationOutput, error::QueryParamsTargetingMapOfEnumStringOperationError> {
 //!     todo!()

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/model.rs

@@ -625,625 +684,826 @@

↥ Expand context

                     duplicate_indices,
                     original: items,
                 },
-628
+            )
         } else {
             Ok(items)
-631
+        }
-632
+    }
-633
+}
 impl ::std::convert::TryFrom<::std::vec::Vec<crate::model::LengthString>> for SetOfLengthString {
     type Error = crate::model::set_of_length_string::ConstraintViolation;
-636
     /// Constructs a `SetOfLengthString` from an [`::std::vec::Vec<crate::model::LengthString>`], failing when the provided value does not satisfy the modeled constraints.
     fn try_from(value: ::std::vec::Vec<crate::model::LengthString>) -> Result<Self, Self::Error> {
         let value = Self::check_unique_items(value)?;
-640
         Ok(Self(value))
-642
+    }
-643
+}
-644

 impl ::std::convert::From<SetOfLengthString> for ::std::vec::Vec<crate::model::LengthString> {
     fn from(value: SetOfLengthString) -> Self {
         value.into_inner()
-648
+    }
-649
+}
 impl crate::constrained::Constrained for SetOfLengthString {
     type Unconstrained =
         crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained;
-653
+}
-654
 #[allow(missing_docs)] // documentation missing in model
 ///
 /// This is a constrained type because its corresponding modeled Smithy shape has one or more
 /// [constraint traits]. Use [`ListWithIndirectlyConstrainedMap::try_from`] to construct values of this type.
 ///
 /// [constraint traits]: https://smithy.io/2.0/spec/constraint-traits.html
 ///
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ListWithIndirectlyConstrainedMap(
     pub(crate)  ::std::vec::Vec<
         ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
     >,
 );
 impl ListWithIndirectlyConstrainedMap {
     /// Returns an immutable reference to the underlying [`::std::vec::Vec<::std::collections::HashMap::<crate::model::LengthString, crate::model::LengthString>>`].
     pub fn inner(
         &self,
     ) -> &::std::vec::Vec<
         ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
     > {
         &self.0
-+
+    }
     /// Consumes the value, returning the underlying [`::std::vec::Vec<::std::collections::HashMap::<crate::model::LengthString, crate::model::LengthString>>`].
     pub fn into_inner(
         self,
     ) -> ::std::vec::Vec<
         ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
     > {
         self.0
-+
+    }
-+
     fn check_length(
         length: usize,
     ) -> Result<(), crate::model::list_with_indirectly_constrained_map::ConstraintViolation> {
         if (1..=10).contains(&length) {
             Ok(())
         } else {
             Err(
                 crate::model::list_with_indirectly_constrained_map::ConstraintViolation::Length(
                     length,
                 ),
-+
+            )
-+
+        }
-+
+    }
-+
+}
 impl
     ::std::convert::TryFrom<
         ::std::vec::Vec<
             ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
         >,
     > for ListWithIndirectlyConstrainedMap
-+
+{
     type Error = crate::model::list_with_indirectly_constrained_map::ConstraintViolation;
-+
     /// Constructs a `ListWithIndirectlyConstrainedMap` from an [`::std::vec::Vec<::std::collections::HashMap::<crate::model::LengthString, crate::model::LengthString>>`], failing when the provided value does not satisfy the modeled constraints.
     fn try_from(
         value: ::std::vec::Vec<
             ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
         >,
     ) -> Result<Self, Self::Error> {
         Self::check_length(value.len())?;
-+
         Ok(Self(value))
-+
+    }
-+
+}
-+
 impl ::std::convert::From<ListWithIndirectlyConstrainedMap>
     for ::std::vec::Vec<
         ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
-+
+    >
-+
+{
     fn from(value: ListWithIndirectlyConstrainedMap) -> Self {
         value.into_inner()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for ListWithIndirectlyConstrainedMap {
     type Unconstrained = crate::unconstrained::list_with_indirectly_constrained_map_unconstrained::ListWithIndirectlyConstrainedMapUnconstrained;
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 ///
 /// This is a constrained type because its corresponding modeled Smithy shape has one or more
 /// [constraint traits]. Use [`ListWithIndirectlyConstrainedList::try_from`] to construct values of this type.
 ///
 /// [constraint traits]: https://smithy.io/2.0/spec/constraint-traits.html
 ///
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ListWithIndirectlyConstrainedList(
     pub(crate) ::std::vec::Vec<::std::vec::Vec<crate::model::LengthString>>,
 );
 impl ListWithIndirectlyConstrainedList {
     /// Returns an immutable reference to the underlying [`::std::vec::Vec<::std::vec::Vec::<crate::model::LengthString>>`].
     pub fn inner(&self) -> &::std::vec::Vec<::std::vec::Vec<crate::model::LengthString>> {
         &self.0
-+
+    }
     /// Consumes the value, returning the underlying [`::std::vec::Vec<::std::vec::Vec::<crate::model::LengthString>>`].
     pub fn into_inner(self) -> ::std::vec::Vec<::std::vec::Vec<crate::model::LengthString>> {
         self.0
-+
+    }
-+
     fn check_length(
         length: usize,
     ) -> Result<(), crate::model::list_with_indirectly_constrained_list::ConstraintViolation> {
         if (1..=10).contains(&length) {
             Ok(())
         } else {
             Err(
                 crate::model::list_with_indirectly_constrained_list::ConstraintViolation::Length(
                     length,
                 ),
-+
+            )
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::TryFrom<::std::vec::Vec<::std::vec::Vec<crate::model::LengthString>>>
     for ListWithIndirectlyConstrainedList
-+
+{
     type Error = crate::model::list_with_indirectly_constrained_list::ConstraintViolation;
-+
     /// Constructs a `ListWithIndirectlyConstrainedList` from an [`::std::vec::Vec<::std::vec::Vec::<crate::model::LengthString>>`], failing when the provided value does not satisfy the modeled constraints.
     fn try_from(
         value: ::std::vec::Vec<::std::vec::Vec<crate::model::LengthString>>,
     ) -> Result<Self, Self::Error> {
         Self::check_length(value.len())?;
-+
         Ok(Self(value))
-+
+    }
-+
+}
-+
 impl ::std::convert::From<ListWithIndirectlyConstrainedList>
     for ::std::vec::Vec<::std::vec::Vec<crate::model::LengthString>>
-+
+{
     fn from(value: ListWithIndirectlyConstrainedList) -> Self {
         value.into_inner()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for ListWithIndirectlyConstrainedList {
     type Unconstrained = crate::unconstrained::list_with_indirectly_constrained_list_unconstrained::ListWithIndirectlyConstrainedListUnconstrained;
-+
+}
-+
 #[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 RecursiveShapesInputOutputNested1 {
     #[allow(missing_docs)] // documentation missing in model
     pub recursive_member: ::std::boxed::Box<crate::model::RecursiveShapesInputOutputNested2>,
-804
+}
 impl RecursiveShapesInputOutputNested1 {
     #[allow(missing_docs)] // documentation missing in model

↧ Expand context

     pub fn recursive_member(&self) -> &crate::model::RecursiveShapesInputOutputNested2 {
         use std::ops::Deref;
         self.recursive_member.deref()
-810
+    }
-811
+}
 impl RecursiveShapesInputOutputNested1 {
     /// Creates a new builder-style object to manufacture [`RecursiveShapesInputOutputNested1`](crate::model::RecursiveShapesInputOutputNested1).
     pub fn builder() -> crate::model::recursive_shapes_input_output_nested1::Builder {
         crate::model::recursive_shapes_input_output_nested1::Builder::default()
-816
+    }
-817
+}
 impl crate::constrained::Constrained for crate::model::RecursiveShapesInputOutputNested1 {
     type Unconstrained = crate::model::recursive_shapes_input_output_nested1::Builder;
-820
+}
-821
 #[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 RecursiveShapesInputOutputNested2 {

@@ -5107,5249 +5166,5486 @@

↥ Expand context

         ),
-5250
+    }
-5251
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 Self::Key(key_constraint_violation) => write!(f, "{}", key_constraint_violation),
                 Self::Value(_, value_constraint_violation) => {
                     write!(f, "{}", value_constraint_violation)
-5258
+                }
-5259
+            }
-5260
+        }
-5261
+    }
-5262
     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 {
                 Self::Key(key_constraint_violation) => {
                     key_constraint_violation.as_validation_exception_field(path)
-5272
+                }
                 Self::Value(key, value_constraint_violation) => value_constraint_violation
                     .as_validation_exception_field(path + "/" + key.as_str()),
-5275
+            }
-5276
+        }
-5277
+    }
-5278
+}
 /// See [`ListWithIndirectlyConstrainedMap`](crate::model::ListWithIndirectlyConstrainedMap).
 pub mod list_with_indirectly_constrained_map {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub enum ConstraintViolation {
         /// Constraint violation error when the list doesn't have the required length
         Length(usize),
         /// Constraint violation error when an element doesn't satisfy its own constraints.
         /// The first component of the tuple is the index in the collection where the
         /// first constraint violation was found.
         #[doc(hidden)]
         Member(
             usize,
             crate::model::indirectly_constrained_map::ConstraintViolation,
         ),
-+
+    }
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let message = match self {
                 Self::Length(length) => {
                     format!("Value with length {} provided for 'com.amazonaws.constraints#ListWithIndirectlyConstrainedMap' failed to satisfy constraint: Member must have length between 1 and 10, inclusive", length)
-+
+                }
                 Self::Member(index, failing_member) => format!(
                     "Value at index {index} failed to satisfy constraint. {}",
                     failing_member
                 ),
             };
             write!(f, "{message}")
-+
+        }
-+
+    }
-+
     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 {
                         Self::Length(length) => crate::model::ValidationExceptionField {
                                 message: format!("Value with length {} at '{}' failed to satisfy constraint: Member must have length between 1 and 10, inclusive", length, &path),
                                 path,
                             },
     Self::Member(index, member_constraint_violation) =>
                         member_constraint_violation.as_validation_exception_field(path + "/" + &index.to_string())
-+
+                    }
-+
+        }
-+
+    }
-+
+}
 pub mod indirectly_constrained_map {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub enum ConstraintViolation {
         #[doc(hidden)]
         Key(crate::model::length_string::ConstraintViolation),
         #[doc(hidden)]
         Value(
             crate::model::LengthString,
             crate::model::length_string::ConstraintViolation,
         ),
-+
+    }
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 Self::Key(key_constraint_violation) => write!(f, "{}", key_constraint_violation),
                 Self::Value(_, value_constraint_violation) => {
                     write!(f, "{}", value_constraint_violation)
-+
+                }
-+
+            }
-+
+        }
-+
+    }
-+
     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 {
                 Self::Key(key_constraint_violation) => {
                     key_constraint_violation.as_validation_exception_field(path)
-+
+                }
                 Self::Value(key, value_constraint_violation) => value_constraint_violation
                     .as_validation_exception_field(path + "/" + key.as_str()),
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`ListWithIndirectlyConstrainedList`](crate::model::ListWithIndirectlyConstrainedList).
 pub mod list_with_indirectly_constrained_list {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub enum ConstraintViolation {
         /// Constraint violation error when the list doesn't have the required length
         Length(usize),
         /// Constraint violation error when an element doesn't satisfy its own constraints.
         /// The first component of the tuple is the index in the collection where the
         /// first constraint violation was found.
         #[doc(hidden)]
         Member(
             usize,
             crate::model::indirectly_constrained_list::ConstraintViolation,
         ),
-+
+    }
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let message = match self {
                 Self::Length(length) => {
                     format!("Value with length {} provided for 'com.amazonaws.constraints#ListWithIndirectlyConstrainedList' failed to satisfy constraint: Member must have length between 1 and 10, inclusive", length)
-+
+                }
                 Self::Member(index, failing_member) => format!(
                     "Value at index {index} failed to satisfy constraint. {}",
                     failing_member
                 ),
             };
             write!(f, "{message}")
-+
+        }
-+
+    }
-+
     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 {
                         Self::Length(length) => crate::model::ValidationExceptionField {
                                 message: format!("Value with length {} at '{}' failed to satisfy constraint: Member must have length between 1 and 10, inclusive", length, &path),
                                 path,
                             },
     Self::Member(index, member_constraint_violation) =>
                         member_constraint_violation.as_validation_exception_field(path + "/" + &index.to_string())
-+
+                    }
-+
+        }
-+
+    }
-+
+}
 pub mod indirectly_constrained_list {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub enum ConstraintViolation {
         /// Constraint violation error when an element doesn't satisfy its own constraints.
         /// The first component of the tuple is the index in the collection where the
         /// first constraint violation was found.
         #[doc(hidden)]
         Member(usize, crate::model::length_string::ConstraintViolation),
-+
+    }
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let message = match self {
                 Self::Member(index, failing_member) => format!(
                     "Value at index {index} failed to satisfy constraint. {}",
                     failing_member
                 ),
             };
             write!(f, "{message}")
-+
+        }
-+
+    }
-+
     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 {
                 Self::Member(index, member_constraint_violation) => member_constraint_violation
                     .as_validation_exception_field(path + "/" + &index.to_string()),
-+
+            }
-+
+        }
-+
+    }
-+
+}
 pub mod recursive_list {
-5458
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub enum ConstraintViolation {
         /// Constraint violation error when an element doesn't satisfy its own constraints.
         /// The first component of the tuple is the index in the collection where the
         /// first constraint violation was found.
         #[doc(hidden)]
         Member(

↧ Expand context

             usize,
             crate::model::recursive_shapes_input_output_nested1::ConstraintViolation,
         ),
-5470
+    }
-5471
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let message = match self {
                 Self::Member(index, failing_member) => format!(
                     "Value at index {index} failed to satisfy constraint. {}",
                     failing_member
                 ),
             };
             write!(f, "{message}")
-5481
+        }
-5482
+    }
-5483
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(

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

@@ -1451,1451 +1510,1611 @@

↥ Expand context

-1451
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_length_map_operation::ser_query_params_targeting_length_map_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1458
+                        }
-1459
+                    }
-1460
+    }
-1461
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryParamsTargetingLengthMapOperationError
-1466
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_length_map_operation::ser_query_params_targeting_length_map_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));

                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1476
+            }
-1477
+        }
-1478
+    }
-1479
+}
-1480
 const CONTENT_TYPE_CONSTRAINEDLISTWITHINDIRECTLYCONSTRAINEDAGGREGATEOPERATION: ::mime::Mime =
     ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput) using modelled bindings.
     pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture {
     type Output = Result<
         crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDLISTWITHINDIRECTLYCONSTRAINEDAGGREGATEOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::de_constrained_list_with_indirectly_constrained_aggregate_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_CONSTRAINEDRECURSIVESHAPESOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ConstrainedRecursiveShapesOperationInput`](crate::input::ConstrainedRecursiveShapesOperationInput) using modelled bindings.
     pub struct ConstrainedRecursiveShapesOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstrainedRecursiveShapesOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1588
+    }
-1589
+}
-1590
 impl std::future::Future for ConstrainedRecursiveShapesOperationInputFuture {

↧ Expand context

     type Output = Result<
         crate::input::ConstrainedRecursiveShapesOperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1596
     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)
-1603
+    }
-1604
+}
-1605
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedRecursiveShapesOperationInput
 where

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

@@ -594,594 +653,695 @@

↥ Expand context

-594
     type Input = crate::input::QueryParamsTargetingLengthMapOperationInput;
     type Output = crate::output::QueryParamsTargetingLengthMapOperationOutput;
     type Error = crate::error::QueryParamsTargetingLengthMapOperationError;
-598
+}
-599
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
     for QueryParamsTargetingLengthMapOperation
-602
+{
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;

-614
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
-617
+    }
-618
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-621
+    }
-622
+}
-623
 #[allow(missing_docs)] // documentation missing in model
 pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperation;
-+
 impl ::aws_smithy_http_server::operation::OperationShape
     for ConstrainedListWithIndirectlyConstrainedAggregateOperation
-+
+{
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "com.amazonaws.constraints#ConstrainedListWithIndirectlyConstrainedAggregateOperation",
             "com.amazonaws.constraints",
             "ConstrainedListWithIndirectlyConstrainedAggregateOperation",
         );
-+
     type Input = crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput;
     type Output = crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput;
     type Error = crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError;
-+
+}
-+
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
     for ConstrainedListWithIndirectlyConstrainedAggregateOperation
-+
+{
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
-+
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
-+
+    }
-+
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 pub struct ConstrainedRecursiveShapesOperation;
-668
 impl ::aws_smithy_http_server::operation::OperationShape for ConstrainedRecursiveShapesOperation {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "com.amazonaws.constraints#ConstrainedRecursiveShapesOperation",
             "com.amazonaws.constraints",
             "ConstrainedRecursiveShapesOperation",
         );

↧ Expand context

-676
     type Input = crate::input::ConstrainedRecursiveShapesOperationInput;
     type Output = crate::output::ConstrainedRecursiveShapesOperationOutput;
     type Error = crate::error::ConstrainedRecursiveShapesOperationError;
-680
+}
-681
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
     for ConstrainedRecursiveShapesOperation
-684
+{
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;

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

@@ -378,378 +437,462 @@

↥ Expand context

         self.map_of_length_string.as_ref()
-379
+    }
-380
+}
 impl QueryParamsTargetingMapOfLengthStringOperationOutput {
     /// Creates a new builder-style object to manufacture [`QueryParamsTargetingMapOfLengthStringOperationOutput`](crate::output::QueryParamsTargetingMapOfLengthStringOperationOutput).
     pub fn builder(
     ) -> crate::output::query_params_targeting_map_of_length_string_operation_output::Builder {
         crate::output::query_params_targeting_map_of_length_string_operation_output::Builder::default()
-386
+    }
-387
+}
-388
 #[allow(missing_docs)] // documentation missing in model
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct QueryParamsTargetingLengthMapOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub length_map: ::std::option::Option<crate::model::ConBMap>,
-394
+}
 impl QueryParamsTargetingLengthMapOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn length_map(&self) -> ::std::option::Option<&crate::model::ConBMap> {

         self.length_map.as_ref()
-399
+    }
-400
+}
 impl QueryParamsTargetingLengthMapOperationOutput {
     /// Creates a new builder-style object to manufacture [`QueryParamsTargetingLengthMapOperationOutput`](crate::output::QueryParamsTargetingLengthMapOperationOutput).
     pub fn builder() -> crate::output::query_params_targeting_length_map_operation_output::Builder {
         crate::output::query_params_targeting_length_map_operation_output::Builder::default()
-405
+    }
-406
+}
-407
 #[allow(missing_docs)] // documentation missing in model
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub a: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedList>,
     #[allow(missing_docs)] // documentation missing in model
     pub b: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedMap>,
-+
+}
 impl ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn a(&self) -> ::std::option::Option<&crate::model::ListWithIndirectlyConstrainedList> {
         self.a.as_ref()
-+
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn b(&self) -> ::std::option::Option<&crate::model::ListWithIndirectlyConstrainedMap> {
         self.b.as_ref()
-+
+    }
-+
+}
 impl ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
     /// Creates a new builder-style object to manufacture [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
     pub fn builder() -> crate::output::constrained_list_with_indirectly_constrained_aggregate_operation_output::Builder{
         crate::output::constrained_list_with_indirectly_constrained_aggregate_operation_output::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 ConstrainedRecursiveShapesOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub nested: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,
     #[allow(missing_docs)] // documentation missing in model
     pub recursive_list: ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
-442
+}

↧ Expand context

 impl ConstrainedRecursiveShapesOperationOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(
         &self,
     ) -> ::std::option::Option<&crate::model::RecursiveShapesInputOutputNested1> {
         self.nested.as_ref()
-449
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn recursive_list(&self) -> &[crate::model::RecursiveShapesInputOutputNested1] {
         use std::ops::Deref;
         self.recursive_list.deref()
-454
+    }
-455
+}
 impl ConstrainedRecursiveShapesOperationOutput {
     /// Creates a new builder-style object to manufacture [`ConstrainedRecursiveShapesOperationOutput`](crate::output::ConstrainedRecursiveShapesOperationOutput).
     pub fn builder() -> crate::output::constrained_recursive_shapes_operation_output::Builder {
         crate::output::constrained_recursive_shapes_operation_output::Builder::default()
-460
+    }
-461
+}
-462

@@ -1442,1467 +1501,1577 @@

↥ Expand context

-1467
     impl ::std::convert::From<Builder> for crate::output::QueryParamsTargetingLengthMapOperationOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-1471
+        }
-1472
+    }
     /// A builder for [`QueryParamsTargetingLengthMapOperationOutput`](crate::output::QueryParamsTargetingLengthMapOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) length_map: ::std::option::Option<crate::model::ConBMap>,
-1477
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_map(mut self, input: ::std::option::Option<crate::model::ConBMap>) -> Self {
             self.length_map = input;
             self
-1483
+        }
         /// Consumes the builder and constructs a [`QueryParamsTargetingLengthMapOperationOutput`](crate::output::QueryParamsTargetingLengthMapOperationOutput).
         pub fn build(self) -> crate::output::QueryParamsTargetingLengthMapOperationOutput {
             self.build_enforcing_all_constraints()

-1487
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> crate::output::QueryParamsTargetingLengthMapOperationOutput {
             crate::output::QueryParamsTargetingLengthMapOperationOutput {
                 length_map: self.length_map,
-1493
+            }
-1494
+        }
-1495
+    }
-1496
+}
 /// See [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
 pub mod constrained_list_with_indirectly_constrained_aggregate_operation_output {
-+
     impl ::std::convert::From<Builder>
         for crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
-+
+    {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) a: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedList>,
         pub(crate) b: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedMap>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn a(
             mut self,
             input: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedList>,
         ) -> Self {
             self.a = input;
             self
-+
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn b(
             mut self,
             input: ::std::option::Option<crate::model::ListWithIndirectlyConstrainedMap>,
         ) -> Self {
             self.b = input;
             self
-+
+        }
         /// Consumes the builder and constructs a [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
         pub fn build(
             self,
         ) -> crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
-+
+        {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
-+
+        {
             crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
                 a: self.a,
                 b: self.b,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`ConstrainedRecursiveShapesOperationOutput`](crate::output::ConstrainedRecursiveShapesOperationOutput).
 pub mod constrained_recursive_shapes_operation_output {
-1550
     #[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 {
         /// `recursive_list` was not provided but it is required when building `ConstrainedRecursiveShapesOperationOutput`.
         MissingRecursiveList,

↧ Expand context

-1558
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingRecursiveList => write!(f, "`recursive_list` was not provided but it is required when building `ConstrainedRecursiveShapesOperationOutput`"),
-1563
+            }
-1564
+        }
-1565
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::output::ConstrainedRecursiveShapesOperationOutput {
         type Error = ConstraintViolation;
-1569
         fn try_from(builder: Builder) -> Result<Self, Self::Error> {
             builder.build()
-1572
+        }
-1573
+    }
     /// A builder for [`ConstrainedRecursiveShapesOperationOutput`](crate::output::ConstrainedRecursiveShapesOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) nested: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,

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

@@ -1,1 +155,167 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) mod shape_constrained_http_bound_shapes_operation;
-3
 pub(crate) mod shape_constrained_http_payload_bound_shape_operation;
-5
 pub(crate) mod shape_constrained_list_with_indirectly_constrained_aggregate_operation;
-+
 pub(crate) mod shape_constrained_recursive_shapes_operation;
-9
 pub(crate) mod shape_constrained_shapes_only_in_output_operation;
-11
 pub(crate) mod shape_constrained_shapes_operation;
-13
 pub(crate) mod shape_event_streams_operation;
-15
 pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation;
-17
 pub(crate) mod shape_non_streaming_blob_operation;
-19
 pub(crate) mod shape_query_params_targeting_length_map_operation;
-21
 pub(crate) mod shape_query_params_targeting_map_of_enum_string_operation;
-23
 pub(crate) mod shape_query_params_targeting_map_of_length_list_of_pattern_string_operation;
-25
 pub(crate) mod shape_query_params_targeting_map_of_length_pattern_string_operation;
-27
 pub(crate) mod shape_query_params_targeting_map_of_length_string_operation;
-29
 pub(crate) mod shape_query_params_targeting_map_of_list_of_enum_string_operation;
-31
 pub(crate) mod shape_query_params_targeting_map_of_list_of_length_pattern_string_operation;
-33
 pub(crate) mod shape_query_params_targeting_map_of_list_of_length_string_operation;
-35
 pub(crate) mod shape_query_params_targeting_map_of_list_of_pattern_string_operation;
-37
 pub(crate) mod shape_query_params_targeting_map_of_pattern_string_operation;
-39
 pub(crate) mod shape_query_params_targeting_map_of_set_of_length_string_operation;
-41
 pub(crate) mod shape_streaming_blob_operation;
-43
 pub(crate) mod shape_constrained_http_bound_shapes_operation_input;
-45
 pub(crate) mod shape_constrained_http_bound_shapes_operation_output;
-47
 pub(crate) mod shape_constrained_http_payload_bound_shape_operation_input;
-49
 pub(crate) mod shape_constrained_http_payload_bound_shape_operation_output;
-51
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
-57
+    }
-58
+}
-59
 pub(crate) mod shape_constrained_list_with_indirectly_constrained_aggregate_operation_output;
-+
 pub(crate) mod shape_constrained_recursive_shapes_operation_output;
-63
 pub(crate) mod shape_constrained_shapes_only_in_output_operation_output;
-65
 pub(crate) mod shape_constrained_shapes_operation_output;
-67
 pub(crate) mod shape_event_stream_error_message;
-69
 pub(crate) mod shape_event_streams_operation_input;
-71
 pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation_input;
-73
 pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation_output;
-75
 pub(crate) mod shape_non_streaming_blob_operation_input;
-77
 pub(crate) mod shape_non_streaming_blob_operation_output;
-79
 pub(crate) mod shape_query_params_targeting_length_map_operation_output;
-81
 pub(crate) mod shape_query_params_targeting_map_of_enum_string_operation_output;
-83
 pub(crate) mod shape_query_params_targeting_map_of_length_list_of_pattern_string_operation_output;
-85
 pub(crate) mod shape_query_params_targeting_map_of_length_pattern_string_operation_output;
-87
 pub(crate) mod shape_query_params_targeting_map_of_length_string_operation_output;
-89
 pub(crate) mod shape_query_params_targeting_map_of_list_of_enum_string_operation_output;
-91
 pub(crate) mod shape_query_params_targeting_map_of_list_of_length_pattern_string_operation_output;
-93
 pub(crate) mod shape_query_params_targeting_map_of_list_of_length_string_operation_output;
-95
 pub(crate) mod shape_query_params_targeting_map_of_list_of_pattern_string_operation_output;
-97
 pub(crate) mod shape_query_params_targeting_map_of_pattern_string_operation_output;
-99
 pub(crate) mod shape_query_params_targeting_map_of_set_of_length_string_operation_output;
-101
 pub(crate) mod shape_streaming_blob_operation_input;
-103
 pub(crate) mod shape_streaming_blob_operation_output;
-105
 pub(crate) mod shape_validation_exception;
-107
 pub(crate) mod shape_con_a;
-109
 pub(crate) mod shape_event;
-111
 pub(crate) mod shape_list_with_indirectly_constrained_list;
-+
 pub(crate) mod shape_list_with_indirectly_constrained_map;
-+
 pub(crate) mod shape_recursive_list;
-117
 pub(crate) mod shape_recursive_shapes_input_output_nested1;
-119
 pub(crate) mod shape_con_b;
-121
 pub(crate) mod shape_con_b_list;
-123
 pub(crate) mod shape_con_b_map;
-125
 pub(crate) mod shape_con_b_set;
-127
 pub(crate) mod shape_constrained_union;
-129
 pub(crate) mod shape_constrained_union_in_output;
-131
 pub(crate) mod shape_event_stream_regular_message;
-133
 pub(crate) mod shape_indirectly_constrained_list;
-+
 pub(crate) mod shape_indirectly_constrained_map;
-+
 pub(crate) mod shape_length_list;
-139
 pub(crate) mod shape_length_list_of_pattern_string;
-141
 pub(crate) mod shape_length_map;
-143
 pub(crate) mod shape_length_set_of_pattern_string;
-145
 pub(crate) mod shape_list_of_length_blob;
-147

↧ Expand context

 pub(crate) mod shape_list_of_length_pattern_string;
-149
 pub(crate) mod shape_list_of_length_string;
-151
 pub(crate) mod shape_list_of_pattern_string;
-153
 pub(crate) mod shape_list_of_range_byte;
-155
 pub(crate) mod shape_list_of_range_integer;
-157
 pub(crate) mod shape_list_of_range_long;
-159
 pub(crate) mod shape_list_of_range_short;
-161
 pub(crate) mod shape_map_of_length_blob;
-163
 pub(crate) mod shape_map_of_length_pattern_string;
-165
 pub(crate) mod shape_map_of_length_string;
-167

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_constrained_list_with_indirectly_constrained_aggregate_operation.rs

@@ -0,1 +0,145 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_constrained_list_with_indirectly_constrained_aggregate_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
 ) -> std::result::Result<
     crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-+
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::de_constrained_list_with_indirectly_constrained_aggregate_operation(bytes.as_ref(), input)?;
-+
+        }
         input.build()?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_response(
     #[allow(unused_variables)]
     output: crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         builder = ::aws_smithy_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 =
             crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation_output::ser_constrained_list_with_indirectly_constrained_aggregate_operation_output_output_output(&output)?
-+
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_error(
     error: &crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError::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_http::header::set_response_header_if_absent(
                                 builder,
                                 ::http::header::CONTENT_TYPE,
                                 "application/json",
                             );
                 builder = ::aws_smithy_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_http::header::set_response_header_if_absent(builder, ::http::header::CONTENT_LENGTH, content_length);
                 builder.status(400).body(::aws_smithy_http_server::body::to_boxed(payload))?
-+
+            }
-+
+        }
     })
-+
+}
-+
 pub(crate) fn de_constrained_list_with_indirectly_constrained_aggregate_operation(
     value: &[u8],
     mut builder: crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input::Builder,
 ) -> Result<
     crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_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() {
                     "a" => {
                         builder = builder.set_a(
                             crate::protocol_serde::shape_list_with_indirectly_constrained_list::de_list_with_indirectly_constrained_list(tokens)?
                         );
-+
+                    }
                     "b" => {
                         builder = builder.set_b(
                             crate::protocol_serde::shape_list_with_indirectly_constrained_map::de_list_with_indirectly_constrained_map(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)
-+
+}

Pages: 1 2 3