Server Test

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

@@ -1,1 +89,121 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:551 */
 pub(crate) fn de_recursive_union_one<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:565 */
     let mut variant = None;
     /* JsonParserGenerator.kt:567 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:568 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             /* JsonParserGenerator.kt:684 */
             loop {
                 /* JsonParserGenerator.kt:685 */
                 match tokens.next().transpose()? {
                     /* JsonParserGenerator.kt:686 */
                     Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                     Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                         /* JsonParserGenerator.kt:576 */
                         if let ::std::option::Option::Some(::std::result::Result::Ok(
                             ::aws_smithy_json::deserialize::Token::ValueNull { .. },
                         )) = tokens.peek()
-35
+                        {
                             let _ = tokens.next().expect("peek returned a token")?;
                             continue;
-38
+                        }
                         /* JsonParserGenerator.kt:585 */
                         let key = key.to_unescaped()?;
                         if key == "__type" {
                             ::aws_smithy_json::deserialize::token::skip_value(tokens)?;
                             continue;
-44
+                        }
                         if variant.is_some() {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "encountered mixed variants in union",
                                 ),
                             );
-51
+                        }
                         /* JsonParserGenerator.kt:598 */
                         variant = match key.as_ref() {
                             /* JsonParserGenerator.kt:601 */
                             "string" => {
                                 /* JsonParserGenerator.kt:611 */
                                 Some(crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained::String(
                                     ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
                                         s.to_unescaped().map(|u|
                                             u.into_owned()
--
+                                        )
                                     ).transpose()?
                                     .ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'string' cannot be null"))?
                                 ))
                                     /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
                                         /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
                                             /* JsonParserGenerator.kt:343 */u.into_owned()
                                         /* JsonParserGenerator.kt:339 */)
                                     /* JsonParserGenerator.kt:354 */).transpose()?
                                     /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'string' cannot be null"))?
                                 /* JsonParserGenerator.kt:611 */))
                                 /* JsonParserGenerator.kt:601 */
-66
+                            }
                             /* JsonParserGenerator.kt:601 */
                             "union" => {
                                 /* JsonParserGenerator.kt:611 */
                                 Some(crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained::Union(
                                     crate::protocol_serde::shape_recursive_union_two::de_recursive_union_two(tokens)?
                                     .map(Box::new)
                                     .ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'union' cannot be null"))?
                                 ))
                                     /* JsonParserGenerator.kt:660 */crate::protocol_serde::shape_recursive_union_two::de_recursive_union_two(tokens)?
                                     /* JsonParserGenerator.kt:314 */.map(Box::new)
                                     /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'union' cannot be null"))?
                                 /* JsonParserGenerator.kt:611 */))
                                 /* JsonParserGenerator.kt:601 */
-76
+                            }
                             variant => return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!("unexpected union variant: {}", variant)))
                             /* JsonParserGenerator.kt:634 */
                             variant => {
                                 return Err(
                                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                         format!("unexpected union variant: {}", variant),
                                     ),
-+
+                                )
                             } /* JsonParserGenerator.kt:598 */
                         };
                         /* JsonParserGenerator.kt:686 */
-87
+                    }
                     /* JsonParserGenerator.kt:695 */
                     other => {
                         return Err(
                         ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                             "expected object key or end object, found: {:?}",
                             other
                         )),
                             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                 format!("expected object key or end object, found: {:?}", other),
                             ),
-94
+                        )
                     } /* JsonParserGenerator.kt:685 */
-96
+                }
                 /* JsonParserGenerator.kt:684 */
-98
+            }
         },
             /* JsonParserGenerator.kt:568 */
-+
+        }
         /* JsonParserGenerator.kt:642 */
         _ => {
             return Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start object or null",
                 ),
-107
+            )
         } /* JsonParserGenerator.kt:567 */
-109
+    }
--
+    }
     /* JsonParserGenerator.kt:649 */
     if variant.is_none() {
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "Union did not contain a valid variant.",
             ),
         );
-117
+    }
     /* JsonParserGenerator.kt:657 */
     Ok(variant)
     /* JsonParserGenerator.kt:551 */
-121
+}

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

@@ -1,1 +88,120 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:551 */
 pub(crate) fn de_recursive_union_two<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:565 */
     let mut variant = None;
     /* JsonParserGenerator.kt:567 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:568 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
         Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
             /* JsonParserGenerator.kt:684 */
             loop {
                 /* JsonParserGenerator.kt:685 */
                 match tokens.next().transpose()? {
                     /* JsonParserGenerator.kt:686 */
                     Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                     Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                         /* JsonParserGenerator.kt:576 */
                         if let ::std::option::Option::Some(::std::result::Result::Ok(
                             ::aws_smithy_json::deserialize::Token::ValueNull { .. },
                         )) = tokens.peek()
-35
+                        {
                             let _ = tokens.next().expect("peek returned a token")?;
                             continue;
-38
+                        }
                         /* JsonParserGenerator.kt:585 */
                         let key = key.to_unescaped()?;
                         if key == "__type" {
                             ::aws_smithy_json::deserialize::token::skip_value(tokens)?;
                             continue;
-44
+                        }
                         if variant.is_some() {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "encountered mixed variants in union",
                                 ),
                             );
-51
+                        }
                         /* JsonParserGenerator.kt:598 */
                         variant = match key.as_ref() {
                             /* JsonParserGenerator.kt:601 */
                             "string" => {
                                 /* JsonParserGenerator.kt:611 */
                                 Some(crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained::String(
                                     ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
                                         s.to_unescaped().map(|u|
                                             u.into_owned()
--
+                                        )
                                     ).transpose()?
                                     .ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'string' cannot be null"))?
                                 ))
                                     /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
                                         /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
                                             /* JsonParserGenerator.kt:343 */u.into_owned()
                                         /* JsonParserGenerator.kt:339 */)
                                     /* JsonParserGenerator.kt:354 */).transpose()?
                                     /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'string' cannot be null"))?
                                 /* JsonParserGenerator.kt:611 */))
                                 /* JsonParserGenerator.kt:601 */
-66
+                            }
                             /* JsonParserGenerator.kt:601 */
                             "union" => {
                                 /* JsonParserGenerator.kt:611 */
                                 Some(crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained::Union(
                                     crate::protocol_serde::shape_recursive_union_one::de_recursive_union_one(tokens)?
                                     .ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'union' cannot be null"))?
                                 ))
                                     /* JsonParserGenerator.kt:660 */crate::protocol_serde::shape_recursive_union_one::de_recursive_union_one(tokens)?
                                     /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'union' cannot be null"))?
                                 /* JsonParserGenerator.kt:611 */))
                                 /* JsonParserGenerator.kt:601 */
-75
+                            }
                             variant => return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!("unexpected union variant: {}", variant)))
                             /* JsonParserGenerator.kt:634 */
                             variant => {
                                 return Err(
                                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                         format!("unexpected union variant: {}", variant),
                                     ),
-+
+                                )
                             } /* JsonParserGenerator.kt:598 */
                         };
                         /* JsonParserGenerator.kt:686 */
-86
+                    }
                     /* JsonParserGenerator.kt:695 */
                     other => {
                         return Err(
                         ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                             "expected object key or end object, found: {:?}",
                             other
                         )),
                             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                 format!("expected object key or end object, found: {:?}", other),
                             ),
-93
+                        )
                     } /* JsonParserGenerator.kt:685 */
-95
+                }
                 /* JsonParserGenerator.kt:684 */
-97
+            }
         },
             /* JsonParserGenerator.kt:568 */
-+
+        }
         /* JsonParserGenerator.kt:642 */
         _ => {
             return Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start object or null",
                 ),
-106
+            )
         } /* JsonParserGenerator.kt:567 */
-108
+    }
--
+    }
     /* JsonParserGenerator.kt:649 */
     if variant.is_none() {
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "Union did not contain a valid variant.",
             ),
         );
-116
+    }
     /* JsonParserGenerator.kt:657 */
     Ok(variant)
     /* JsonParserGenerator.kt:551 */
-120
+}

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

@@ -1,1 +150,216 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* RustType.kt:516 */
 #[allow(clippy::unnecessary_wraps)]
 /* ServerHttpBoundProtocolGenerator.kt:383 */
 pub async fn de_sensitive_validation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
 ) -> std::result::Result<
     crate::input::SensitiveValidationInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-10
+>
 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>,
-16
+{
     /* ServerHttpBoundProtocolGenerator.kt:399 */
     Ok({
         /* RustType.kt:516 */
         #[allow(unused_mut)]
         /* ServerHttpBoundProtocolGenerator.kt:723 */
         let mut input = crate::input::sensitive_validation_input::Builder::default();
         /* RustType.kt:516 */
         #[allow(unused_variables)]
         /* ServerHttpBoundProtocolGenerator.kt:728 */
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         /* ServerHttpBoundProtocolGenerator.kt:745 */
         let bytes = ::hyper::body::to_bytes(body).await?;
         /* ServerHttpBoundProtocolGenerator.kt:768 */
         if !bytes.is_empty() {
             /* ServerHttpBoundProtocolGenerator.kt:769 */
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_sensitive_validation::de_sensitive_validation(
                 bytes.as_ref(),
                 input,
             )?;
             /* ServerHttpBoundProtocolGenerator.kt:768 */
-43
+        }
         /* ServerHttpBoundProtocolGenerator.kt:834 */
         input.build()?
         /* ServerHttpBoundProtocolGenerator.kt:399 */
     })
     /* ServerHttpBoundProtocolGenerator.kt:383 */
-49
+}
-50
 /* RustType.kt:516 */
 #[allow(clippy::unnecessary_wraps)]
 /* ServerHttpBoundProtocolGenerator.kt:421 */
 pub fn ser_sensitive_validation_http_response(
     #[allow(unused_variables)] output: crate::output::SensitiveValidationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     /* ServerHttpBoundProtocolGenerator.kt:433 */
     Ok({
         /* RustType.kt:516 */
         #[allow(unused_mut)]
         /* ServerHttpBoundProtocolGenerator.kt:523 */
         let mut builder = ::http::Response::builder();
         /* ServerHttpBoundProtocolGenerator.kt:597 */
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             "application/json",
         );
         /* ServerHttpBoundProtocolGenerator.kt:682 */
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         /* ServerHttpBoundProtocolGenerator.kt:561 */
         let payload =
             /* HttpBoundProtocolPayloadGenerator.kt:235 */""
         /* ServerHttpBoundProtocolGenerator.kt:561 */;
         /* ServerHttpBoundProtocolGenerator.kt:663 */
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         /* ServerHttpBoundProtocolGenerator.kt:567 */
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         /* ServerHttpBoundProtocolGenerator.kt:575 */
         builder.body(body)?
         /* ServerHttpBoundProtocolGenerator.kt:433 */
     })
     /* ServerHttpBoundProtocolGenerator.kt:421 */
-93
+}
-94
 /* RustType.kt:516 */
 #[allow(clippy::unnecessary_wraps)]
 /* ServerHttpBoundProtocolGenerator.kt:447 */
 pub fn ser_sensitive_validation_http_error(
     error: &crate::error::SensitiveValidationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     /* ServerHttpBoundProtocolGenerator.kt:452 */
     Ok({
         /* ServerHttpBoundProtocolGenerator.kt:468 */
         match error {
             /* ServerHttpBoundProtocolGenerator.kt:476 */
             crate::error::SensitiveValidationError::ValidationException(output) => {
                 /* ServerHttpBoundProtocolGenerator.kt:477 */
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 /* RustType.kt:516 */
                 #[allow(unused_mut)]
                 /* ServerHttpBoundProtocolGenerator.kt:487 */
                 let mut builder = ::http::Response::builder();
                 /* ServerHttpBoundProtocolGenerator.kt:597 */
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     "application/json",
                 );
                 /* ServerHttpBoundProtocolGenerator.kt:597 */
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     "ValidationException",
                 );
                 /* ServerHttpBoundProtocolGenerator.kt:663 */
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     content_length,
                 );
                 /* ServerHttpBoundProtocolGenerator.kt:504 */
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
                 /* ServerHttpBoundProtocolGenerator.kt:476 */
             } /* ServerHttpBoundProtocolGenerator.kt:468 */
-141
+        }
--
+        }
         /* ServerHttpBoundProtocolGenerator.kt:452 */
     })
     /* ServerHttpBoundProtocolGenerator.kt:447 */
-145
+}
-146
 /* JsonParserGenerator.kt:148 */
 pub(crate) fn de_sensitive_validation(
     value: &[u8],
     mut builder: crate::input::sensitive_validation_input::Builder,
 ) -> ::std::result::Result<
     crate::input::sensitive_validation_input::Builder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     /* JsonParserGenerator.kt:153 */
     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())?;
     /* JsonParserGenerator.kt:684 */
     loop {
         /* JsonParserGenerator.kt:685 */
         match tokens.next().transpose()? {
             /* JsonParserGenerator.kt:686 */
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                 /* JsonParserGenerator.kt:260 */
                 match key.to_unescaped()?.as_ref() {
                     /* JsonParserGenerator.kt:262 */
                     "string" => {
                         /* JsonParserGenerator.kt:272 */
                         builder = builder.set_string(
                             /* JsonParserGenerator.kt:354 */
                             ::aws_smithy_json::deserialize::token::expect_string_or_null(
                                 tokens.next(),
                             )?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                             .map(|s|
                                 /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
                                     /* JsonParserGenerator.kt:348 */u.into_owned()
                                 /* JsonParserGenerator.kt:339 */) /* JsonParserGenerator.kt:354 */)
                             .transpose()?, /* JsonParserGenerator.kt:272 */
                         );
                         /* JsonParserGenerator.kt:262 */
-185
+                    }
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
                     /* JsonParserGenerator.kt:290 */
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:260 */
-188
+                }
                 /* JsonParserGenerator.kt:686 */
-190
+            }
             /* JsonParserGenerator.kt:695 */
             other => {
                 return Err(
                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                         "expected object key or end object, found: {:?}",
                         other
                     )),
-198
+                )
             } /* JsonParserGenerator.kt:685 */
-200
+        }
         /* JsonParserGenerator.kt:684 */
-202
+    }
--
+    }
     /* JsonParserGenerator.kt:250 */
     if tokens.next().is_some() {
         /* JsonParserGenerator.kt:251 */
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "found more JSON tokens after completing parsing",
             ),
         );
         /* JsonParserGenerator.kt:250 */
-212
+    }
     /* JsonParserGenerator.kt:163 */
     Ok(builder)
     /* JsonParserGenerator.kt:148 */
-216
+}

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

@@ -1,1 +54,78 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_short_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::short_set_unconstrained::ShortSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-34
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         let value = ::aws_smithy_json::deserialize::token::expect_number_or_null(
                             tokens.next(),
                         )?
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             /* JsonParserGenerator.kt:365 */::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
                                                 .map(i16::try_from)
                         .transpose()?;
                                                 .transpose()?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-54
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-57
+                }
                 /* JsonParserGenerator.kt:408 */
-59
+            }
--
+            }
             /* JsonParserGenerator.kt:444 */
             Ok(Some(
                 crate::unconstrained::short_set_unconstrained::ShortSetUnconstrained(items),
             ))
             /* JsonParserGenerator.kt:713 */
-65
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-76
+    }
     /* JsonParserGenerator.kt:398 */
-78
+}

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

@@ -1,1 +52,78 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_string_list<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<::std::vec::Vec<::std::string::String>>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-34
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
                             tokens.next(),
                         )?
                         .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                         .transpose()?;
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
                                 /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
                                     /* JsonParserGenerator.kt:348 */u.into_owned()
                                 /* JsonParserGenerator.kt:339 */)
                             /* JsonParserGenerator.kt:354 */).transpose()?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-56
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-59
+                }
                 /* JsonParserGenerator.kt:408 */
-61
+            }
--
+            }
             /* JsonParserGenerator.kt:446 */
             Ok(Some(items))
             /* JsonParserGenerator.kt:713 */
-65
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-76
+    }
     /* JsonParserGenerator.kt:398 */
-78
+}

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

@@ -1,1 +54,80 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_string_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::string_set_unconstrained::StringSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-34
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
                             tokens.next(),
                         )?
                         .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                         .transpose()?;
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
                                 /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
                                     /* JsonParserGenerator.kt:348 */u.into_owned()
                                 /* JsonParserGenerator.kt:339 */)
                             /* JsonParserGenerator.kt:354 */).transpose()?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-56
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-59
+                }
                 /* JsonParserGenerator.kt:408 */
-61
+            }
--
+            }
             /* JsonParserGenerator.kt:444 */
             Ok(Some(
                 crate::unconstrained::string_set_unconstrained::StringSetUnconstrained(items),
             ))
             /* JsonParserGenerator.kt:713 */
-67
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-78
+    }
     /* JsonParserGenerator.kt:398 */
-80
+}

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

@@ -1,1 +53,76 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_structure_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::structure_set_unconstrained::StructureSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-34
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             crate::protocol_serde::shape_greeting_struct::de_greeting_struct(
                                 tokens,
                             )?;
                             /* JsonParserGenerator.kt:544 */crate::protocol_serde::shape_greeting_struct::de_greeting_struct(tokens)?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-52
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-55
+                }
                 /* JsonParserGenerator.kt:408 */
-57
+            }
--
+            }
             /* JsonParserGenerator.kt:444 */
             Ok(Some(
                 crate::unconstrained::structure_set_unconstrained::StructureSetUnconstrained(items),
             ))
             /* JsonParserGenerator.kt:713 */
-63
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-74
+    }
     /* JsonParserGenerator.kt:398 */
-76
+}

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

@@ -1,1 +38,62 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_structure_set_with_no_key<'a, I>(tokens: &mut ::std::iter::Peekable<I>) -> ::std::result::Result<Option<crate::unconstrained::structure_set_with_no_key_unconstrained::StructureSetWithNoKeyUnconstrained>, ::aws_smithy_json::deserialize::error::DeserializeError>
 where I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-22
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             crate::protocol_serde::shape_missing_key_structure::de_missing_key_structure(tokens)?
--
+                        ;
                             /* JsonParserGenerator.kt:544 */crate::protocol_serde::shape_missing_key_structure::de_missing_key_structure(tokens)?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-40
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-43
+                }
                 /* JsonParserGenerator.kt:408 */
-45
+            }
--
+            }
             /* JsonParserGenerator.kt:444 */
             Ok(Some(crate::unconstrained::structure_set_with_no_key_unconstrained::StructureSetWithNoKeyUnconstrained(items)))
             /* JsonParserGenerator.kt:713 */
-49
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-60
+    }
     /* JsonParserGenerator.kt:398 */
-62
+}

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

@@ -1,1 +54,76 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_timestamp_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::timestamp_set_unconstrained::TimestampSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-34
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             ::aws_smithy_json::deserialize::token::expect_timestamp_or_null(
                                 tokens.next(),
                                 ::aws_smithy_types::date_time::Format::EpochSeconds,
                             )?;
                             /* JsonParserGenerator.kt:384 */::aws_smithy_json::deserialize::token::expect_timestamp_or_null(tokens.next(), ::aws_smithy_types::date_time::Format::EpochSeconds)?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-52
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-55
+                }
                 /* JsonParserGenerator.kt:408 */
-57
+            }
--
+            }
             /* JsonParserGenerator.kt:444 */
             Ok(Some(
                 crate::unconstrained::timestamp_set_unconstrained::TimestampSetUnconstrained(items),
             ))
             /* JsonParserGenerator.kt:713 */
-63
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-74
+    }
     /* JsonParserGenerator.kt:398 */
-76
+}

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

@@ -1,1 +50,76 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonParserGenerator.kt:398 */
 pub(crate) fn de_union_set<'a, I>(
     tokens: &mut ::std::iter::Peekable<I>,
 ) -> ::std::result::Result<
     Option<crate::unconstrained::union_set_unconstrained::UnionSetUnconstrained>,
     ::aws_smithy_json::deserialize::error::DeserializeError,
-8
+>
 where
     I: Iterator<
         Item = Result<
             ::aws_smithy_json::deserialize::Token<'a>,
             ::aws_smithy_json::deserialize::error::DeserializeError,
         >,
     >,
-16
+{
     /* JsonParserGenerator.kt:712 */
     match tokens.next().transpose()? {
         /* JsonParserGenerator.kt:713 */
         Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
         Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
             /* JsonParserGenerator.kt:407 */
             let mut items = Vec::new();
             /* JsonParserGenerator.kt:408 */
             loop {
                 /* JsonParserGenerator.kt:409 */
                 match tokens.peek() {
                     /* JsonParserGenerator.kt:410 */
                     Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
                         /* JsonParserGenerator.kt:411 */
                         tokens.next().transpose().unwrap();
                         break;
                         /* JsonParserGenerator.kt:410 */
-34
+                    }
                     /* JsonParserGenerator.kt:413 */
                     _ => {
                         let value = crate::protocol_serde::shape_foo_union::de_foo_union(tokens)?;
                         /* JsonParserGenerator.kt:419 */
                         let value =
                             /* JsonParserGenerator.kt:660 */crate::protocol_serde::shape_foo_union::de_foo_union(tokens)?
                         /* JsonParserGenerator.kt:419 */;
                         /* JsonParserGenerator.kt:422 */
                         if let Some(value) = value {
                             items.push(value);
                         } else {
-+
+                        }
                         /* JsonParserGenerator.kt:430 */
                         else {
                             return Err(
                                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                                     "dense list cannot contain null values",
                                 ),
                             );
-52
+                        }
                         /* JsonParserGenerator.kt:413 */
                     } /* JsonParserGenerator.kt:409 */
-55
+                }
                 /* JsonParserGenerator.kt:408 */
-57
+            }
--
+            }
             /* JsonParserGenerator.kt:444 */
             Ok(Some(
                 crate::unconstrained::union_set_unconstrained::UnionSetUnconstrained(items),
             ))
             /* JsonParserGenerator.kt:713 */
-63
+        }
         _ => Err(
         /* JsonParserGenerator.kt:722 */
         _ => {
             /* JsonParserGenerator.kt:723 */
             Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start array or null",
                 ),
         ),
-+
+            )
             /* JsonParserGenerator.kt:722 */
         } /* JsonParserGenerator.kt:712 */
-74
+    }
     /* JsonParserGenerator.kt:398 */
-76
+}

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

@@ -1,1 +35,58 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonSerializerGenerator.kt:213 */
 pub fn ser_validation_exception_error(
     value: &crate::error::ValidationException,
 ) -> ::std::result::Result<String, ::aws_smithy_types::error::operation::SerializationError> {
     /* JsonSerializerGenerator.kt:218 */
     let mut out = ::std::string::String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     /* JsonSerializerGenerator.kt:375 */
     crate::protocol_serde::shape_validation_exception::ser_validation_exception(
         &mut object,
         value,
     )?;
     /* JsonSerializerGenerator.kt:227 */
     object.finish();
     Ok(out)
     /* JsonSerializerGenerator.kt:213 */
-18
+}
-19
 /* JsonSerializerGenerator.kt:358 */
 pub fn ser_validation_exception(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::error::ValidationException,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     /* JsonSerializerGenerator.kt:382 */
     if let Some(var_1) = &input.field_list {
         /* JsonSerializerGenerator.kt:484 */
         let mut array_2 = object.key("fieldList").start_array();
         /* JsonSerializerGenerator.kt:524 */
         for item_3 in var_1 {
             /* SerializerUtil.kt:42 */
-32
+            {
                 /* JsonSerializerGenerator.kt:495 */
                 #[allow(unused_mut)]
                 /* JsonSerializerGenerator.kt:496 */
                 let mut object_4 = array_2.value().start_object();
                 /* JsonSerializerGenerator.kt:375 */
                 crate::protocol_serde::shape_validation_exception_field::ser_validation_exception_field(&mut object_4, item_3)?;
                 /* JsonSerializerGenerator.kt:515 */
                 object_4.finish();
                 /* SerializerUtil.kt:42 */
-42
+            }
             /* JsonSerializerGenerator.kt:524 */
-44
+        }
         /* JsonSerializerGenerator.kt:486 */
         array_2.finish();
         /* JsonSerializerGenerator.kt:382 */
-48
+    }
     /* SerializerUtil.kt:42 */
-50
+    {
         /* JsonSerializerGenerator.kt:423 */
         object.key("message").string(input.message.as_str());
         /* SerializerUtil.kt:42 */
-54
+    }
     /* JsonSerializerGenerator.kt:372 */
     Ok(())
     /* JsonSerializerGenerator.kt:358 */
-58
+}

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

@@ -1,1 +13,22 @@

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

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

@@ -1,1 +31,32 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerServiceGenerator.kt:795 */
 /// The service builder for [`RestJsonValidation`].
 ///
 /// Constructed via [`RestJsonValidation::builder`].
 pub struct RestJsonValidationBuilder<Body, L, HttpPl, ModelPl> {
     malformed_enum: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_length: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_length_override: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_length_query_string: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_pattern: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_pattern_override: Option<::aws_smithy_http_server::routing::Route<Body>>,

↧ Expand context

     malformed_range: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_range_override: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_required: Option<::aws_smithy_http_server::routing::Route<Body>>,
     malformed_unique_items: Option<::aws_smithy_http_server::routing::Route<Body>>,
     recursive_structures: Option<::aws_smithy_http_server::routing::Route<Body>>,
     sensitive_validation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     layer: L,
     http_plugin: HttpPl,
     model_plugin: ModelPl,
-22
+}
-23
 impl<Body, L, HttpPl, ModelPl> RestJsonValidationBuilder<Body, L, HttpPl, ModelPl> {
     /// Sets the [`MalformedEnum`](crate::operation_shape::MalformedEnum) 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

@@ -2692,2693 +2751,2753 @@

↥ Expand context

-2693
+}
 impl<L>
     ::aws_smithy_http_server::service::ContainsOperation<
         crate::operation_shape::RecursiveStructures,
     > for RestJsonValidation<L>
-2698
+{
     const VALUE: Operation = Operation::RecursiveStructures;
-2700
+}
 impl<L>
     ::aws_smithy_http_server::service::ContainsOperation<
         crate::operation_shape::SensitiveValidation,
     > for RestJsonValidation<L>
-2705
+{
     const VALUE: Operation = Operation::SensitiveValidation;
-2707
+}
-2708
 impl<S> ::aws_smithy_http_server::service::ServiceShape for RestJsonValidation<S> {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson.validation#RestJsonValidation",

             "aws.protocoltests.restjson.validation",
             "RestJsonValidation",
         );
-2716
     const VERSION: Option<&'static str> = Some("2021-08-19");
-2718
     type Protocol = ::aws_smithy_http_server::protocol::rest_json_1::RestJson1;
-2720
     type Operations = Operation;
-2722
+}
 /* ServiceConfigGenerator.kt:178 */
 /// Configuration for the [`RestJsonValidation`]. This is the central place where to register and
 /// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
 ///
 /// ```rust,no_run
 /// # use rest_json_validation::RestJsonValidationConfig;
 /// # use ::aws_smithy_http_server::plugin::IdentityPlugin;
 /// # use ::tower::layer::util::Identity;
 /// # let authentication_plugin = IdentityPlugin;
 /// # let authorization_plugin = IdentityPlugin;
 /// # let server_request_id_provider_layer = Identity::new();

↧ Expand context

 /// let config = RestJsonValidationConfig::builder()
 ///     // Layers get executed first...
 ///     .layer(server_request_id_provider_layer)
 ///     // ...then HTTP plugins...
 ///     .http_plugin(authentication_plugin)
 ///     // ...and right after deserialization, model plugins.
 ///     .model_plugin(authorization_plugin)
 ///     .build();
 /// ```
 ///
 /// See the [`plugin`] system for details.
 ///
 /// [`plugin`]: ::aws_smithy_http_server::plugin
 #[derive(::std::fmt::Debug)]
 pub struct RestJsonValidationConfig<L, H, M> {
     layers: L,
     http_plugins: H,
     model_plugins: M,
-2752
+}
-2753

@@ -2813,2815 +2872,2875 @@

↥ Expand context

     /// [plugin]: ::aws_smithy_http_server::plugin
     // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn model_plugin<NewPlugin: ::aws_smithy_http_server::plugin::ModelMarker>(
         self,
         model_plugin: NewPlugin,
     ) -> RestJsonValidationConfigBuilder<
         L,
         H,
         ::aws_smithy_http_server::plugin::PluginStack<NewPlugin, M>,
     > {
         RestJsonValidationConfigBuilder {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: ::aws_smithy_http_server::plugin::PluginStack::new(
                 model_plugin,
                 self.model_plugins,
             ),
-2833
+        }
-2834
+    }

-2835
     /// Build the configuration.
     pub fn build(self) -> super::RestJsonValidationConfig<L, H, M> {
         super::RestJsonValidationConfig {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-2842
+        }
-2843
+    }
-2844
+}
 /* ScopeMacroGenerator.kt:81 */
 /// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
 ///
 /// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
 /// of the service and any operations _not_ specified will be placed in the opposing group.
 ///
 /// # Example
 ///
 /// ```rust
 /// scope! {
 ///     /// Includes [`MalformedEnum`], excluding all other operations.

↧ Expand context

 ///     struct ScopeA {
 ///         includes: [MalformedEnum]
 ///     }
 /// }
 ///
 /// scope! {
 ///     /// Excludes [`MalformedEnum`], excluding all other operations.
 ///     struct ScopeB {
 ///         excludes: [MalformedEnum]
 ///     }
 /// }
 ///
 /// # use rest_json_validation::server::plugin::{Plugin, Scoped};
 /// # use rest_json_validation::scope;
 /// # struct MockPlugin;
 /// # impl<S, Op, T> Plugin<S, Op, T> for MockPlugin { type Output = u32; fn apply(&self, input: T) -> u32 { 3 } }
 /// # let scoped_a = Scoped::new::<ScopeA>(MockPlugin);
 /// # let scoped_b = Scoped::new::<ScopeB>(MockPlugin);
 /// # let a = Plugin::<(), rest_json_validation::operation_shape::MalformedEnum, u64>::apply(&scoped_a, 6);
 /// # let b = Plugin::<(), rest_json_validation::operation_shape::MalformedEnum, u64>::apply(&scoped_b, 6);

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

@@ -1,1 +0,7 @@

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

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

@@ -1,1 +924,1197 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /* UnconstrainedUnionGenerator.kt:121 */
 impl crate::constrained::Constrained for crate::model::RecursiveUnionOne {
     type Unconstrained =
         crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained;
-7
+}
-8
 impl From<crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::RecursiveUnionOne>
-11
+{
     fn from(
         value: crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained,
     ) -> Self {
         Self::Unconstrained(value)
-16
+    }
-17
+}
-18
 /* UnconstrainedUnionGenerator.kt:121 */
 impl crate::constrained::Constrained for crate::model::RecursiveUnionTwo {
     type Unconstrained =
         crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained;
-23
+}
-24
 impl From<crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::RecursiveUnionTwo>
-27
+{
     fn from(
         value: crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained,
     ) -> Self {
         Self::Unconstrained(value)
-32
+    }
-33
+}
-34
 /* UnconstrainedUnionGenerator.kt:121 */
 impl crate::constrained::Constrained for crate::model::PatternUnionOverride {
     type Unconstrained = crate::unconstrained::pattern_union_override_unconstrained::PatternUnionOverrideUnconstrained;
-38
+}
-39
 impl From<crate::unconstrained::pattern_union_override_unconstrained::PatternUnionOverrideUnconstrained> for crate::constrained::MaybeConstrained<crate::model::PatternUnionOverride> {
                 fn from(value: crate::unconstrained::pattern_union_override_unconstrained::PatternUnionOverrideUnconstrained) -> Self {
                     Self::Unconstrained(value)
-43
+                }
-44
+            }
-45
 /* UnconstrainedUnionGenerator.kt:121 */
 impl crate::constrained::Constrained for crate::model::PatternUnion {
     type Unconstrained =
         crate::unconstrained::pattern_union_unconstrained::PatternUnionUnconstrained;
-50
+}
-51
 impl From<crate::unconstrained::pattern_union_unconstrained::PatternUnionUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::PatternUnion>
-54
+{
     fn from(
         value: crate::unconstrained::pattern_union_unconstrained::PatternUnionUnconstrained,
     ) -> Self {
         Self::Unconstrained(value)
-59
+    }
-60
+}
-61
 /* UnconstrainedUnionGenerator.kt:121 */
 impl crate::constrained::Constrained for crate::model::EnumUnion {
     type Unconstrained = crate::unconstrained::enum_union_unconstrained::EnumUnionUnconstrained;
-65
+}
-66
 impl From<crate::unconstrained::enum_union_unconstrained::EnumUnionUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::EnumUnion>
-69
+{
     fn from(value: crate::unconstrained::enum_union_unconstrained::EnumUnionUnconstrained) -> Self {
         Self::Unconstrained(value)
-72
+    }
-73
+}
-74
 pub(crate) mod recursive_union_one_unconstrained {
-76
     /* UnconstrainedUnionGenerator.kt:82 */
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum RecursiveUnionOneUnconstrained {
         String(::std::string::String),
         Union(::std::boxed::Box<crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained>),
--
+    }
         /* UnconstrainedUnionGenerator.kt:95 */String(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */Union(::std::boxed::Box<crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained>),
     /* UnconstrainedUnionGenerator.kt:82 */}
     /* UnconstrainedUnionGenerator.kt:103 */
     impl ::std::convert::TryFrom<RecursiveUnionOneUnconstrained> for crate::model::RecursiveUnionOne {
         type Error = crate::model::recursive_union_one::ConstraintViolation;
-87
         fn try_from(
             value: RecursiveUnionOneUnconstrained,
         ) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained::String(unconstrained) => Self::String(
                 unconstrained
                                         .try_into()
-96
-97
                                         .map_err(Self::Error::String)?
             ),
             crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained::Union(unconstrained) => Self::Union(
                 (*unconstrained)
                                         .try_into()
                                         .map(Box::new)
                                         .map_err(Box::new)
                                         .map_err(Self::Error::Union)?
             ),
-107
+        }
-108
+    )
-109
+        }
-110
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-113
+}
 pub(crate) mod recursive_union_two_unconstrained {
-115
     /* UnconstrainedUnionGenerator.kt:82 */
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum RecursiveUnionTwoUnconstrained {
         String(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */ String(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */
         Union(
             crate::unconstrained::recursive_union_one_unconstrained::RecursiveUnionOneUnconstrained,
         ),
         /* UnconstrainedUnionGenerator.kt:82 */
-126
+    }
     /* UnconstrainedUnionGenerator.kt:103 */
     impl ::std::convert::TryFrom<RecursiveUnionTwoUnconstrained> for crate::model::RecursiveUnionTwo {
         type Error = crate::model::recursive_union_two::ConstraintViolation;
-130
         fn try_from(
             value: RecursiveUnionTwoUnconstrained,
         ) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained::String(unconstrained) => Self::String(
                 unconstrained
                                         .try_into()
-139
-140
                                         .map_err(Self::Error::String)?
             ),
             crate::unconstrained::recursive_union_two_unconstrained::RecursiveUnionTwoUnconstrained::Union(unconstrained) => Self::Union(
                 unconstrained
                                         .try_into()
-146
-147
                                         .map_err(Self::Error::Union)?
             ),
-150
+        }
-151
+    )
-152
+        }
-153
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-156
+}
 pub(crate) mod union_set_unconstrained {
-158
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct UnionSetUnconstrained(pub(crate) std::vec::Vec<crate::model::FooUnion>);
-162
     impl From<UnionSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::UnionSet> {
         fn from(value: UnionSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-166
+        }
-167
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<UnionSetUnconstrained> for crate::model::UnionSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::union_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: UnionSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-179
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-181
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-184
+}
 pub(crate) mod structure_set_with_no_key_unconstrained {
-186
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct StructureSetWithNoKeyUnconstrained(
         pub(crate) std::vec::Vec<crate::model::missing_key_structure::Builder>,
     );
-192
     impl From<StructureSetWithNoKeyUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::StructureSetWithNoKey>
-195
+    {
         fn from(value: StructureSetWithNoKeyUnconstrained) -> Self {
             Self::Unconstrained(value)
-198
+        }
-199
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<StructureSetWithNoKeyUnconstrained>
         for crate::model::StructureSetWithNoKey
-203
+    {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::structure_set_with_no_key::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(
             value: StructureSetWithNoKeyUnconstrained,
         ) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::MissingKeyStructure>,
-213
+                (
                     usize,
                     crate::model::missing_key_structure::ConstraintViolation,
                 ),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-232
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-234
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-237
+}
 pub(crate) mod structure_set_unconstrained {
-239
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct StructureSetUnconstrained(
         pub(crate) std::vec::Vec<crate::model::GreetingStruct>,
     );
-245
     impl From<StructureSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::StructureSet>
-248
+    {
         fn from(value: StructureSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-251
+        }
-252
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<StructureSetUnconstrained> for crate::model::StructureSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::structure_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: StructureSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-264
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-266
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-269
+}
 pub(crate) mod list_set_unconstrained {
-271
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct ListSetUnconstrained(
         pub(crate) std::vec::Vec<::std::vec::Vec<::std::string::String>>,
     );
-277
     impl From<ListSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ListSet> {
         fn from(value: ListSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-281
+        }
-282
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<ListSetUnconstrained> for crate::model::ListSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::list_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: ListSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-294
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-296
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-299
+}
 pub(crate) mod integer_enum_set_unconstrained {
-301
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct IntegerEnumSetUnconstrained(pub(crate) std::vec::Vec<i32>);
-305
     impl From<IntegerEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::IntegerEnumSet>
-308
+    {
         fn from(value: IntegerEnumSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-311
+        }
-312
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<IntegerEnumSetUnconstrained> for crate::model::IntegerEnumSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::integer_enum_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: IntegerEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-324
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-326
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-329
+}
 pub(crate) mod foo_enum_set_unconstrained {
-331
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumSetUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-335
     impl From<FooEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::FooEnumSet>
-338
+    {
         fn from(value: FooEnumSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-341
+        }
-342
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<FooEnumSetUnconstrained> for crate::model::FooEnumSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::foo_enum_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: FooEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-368
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-370
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-373
+}
 pub(crate) mod http_date_set_unconstrained {
-375
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct HttpDateSetUnconstrained(
         pub(crate) std::vec::Vec<::aws_smithy_types::DateTime>,
     );
-381
     impl From<HttpDateSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::HttpDateSet>
-384
+    {
         fn from(value: HttpDateSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-387
+        }
-388
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<HttpDateSetUnconstrained> for crate::model::HttpDateSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::http_date_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: HttpDateSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-400
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-402
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-405
+}
 pub(crate) mod date_time_set_unconstrained {
-407
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct DateTimeSetUnconstrained(
         pub(crate) std::vec::Vec<::aws_smithy_types::DateTime>,
     );
-413
     impl From<DateTimeSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::DateTimeSet>
-416
+    {
         fn from(value: DateTimeSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-419
+        }
-420
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<DateTimeSetUnconstrained> for crate::model::DateTimeSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::date_time_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: DateTimeSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-432
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-434
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-437
+}
 pub(crate) mod timestamp_set_unconstrained {
-439
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct TimestampSetUnconstrained(
         pub(crate) std::vec::Vec<::aws_smithy_types::DateTime>,
     );
-445
     impl From<TimestampSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::TimestampSet>
-448
+    {
         fn from(value: TimestampSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-451
+        }
-452
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<TimestampSetUnconstrained> for crate::model::TimestampSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::timestamp_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: TimestampSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-464
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-466
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-469
+}
 pub(crate) mod long_set_unconstrained {
-471
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct LongSetUnconstrained(pub(crate) std::vec::Vec<i64>);
-475
     impl From<LongSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::LongSet> {
         fn from(value: LongSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-479
+        }
-480
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<LongSetUnconstrained> for crate::model::LongSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::long_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: LongSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-492
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-494
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-497
+}
 pub(crate) mod integer_set_unconstrained {
-499
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct IntegerSetUnconstrained(pub(crate) std::vec::Vec<i32>);
-503
     impl From<IntegerSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::IntegerSet>
-506
+    {
         fn from(value: IntegerSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-509
+        }
-510
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<IntegerSetUnconstrained> for crate::model::IntegerSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::integer_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: IntegerSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-522
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-524
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-527
+}
 pub(crate) mod short_set_unconstrained {
-529
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct ShortSetUnconstrained(pub(crate) std::vec::Vec<i16>);
-533
     impl From<ShortSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ShortSet> {
         fn from(value: ShortSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-537
+        }
-538
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<ShortSetUnconstrained> for crate::model::ShortSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::short_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: ShortSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-550
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-552
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-555
+}
 pub(crate) mod byte_set_unconstrained {
-557
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct ByteSetUnconstrained(pub(crate) std::vec::Vec<i8>);
-561
     impl From<ByteSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ByteSet> {
         fn from(value: ByteSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-565
+        }
-566
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<ByteSetUnconstrained> for crate::model::ByteSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::byte_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: ByteSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-578
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-580
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-583
+}
 pub(crate) mod string_set_unconstrained {
-585
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct StringSetUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-589
     impl From<StringSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::StringSet>
-592
+    {
         fn from(value: StringSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-595
+        }
-596
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<StringSetUnconstrained> for crate::model::StringSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::string_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: StringSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-608
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-610
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-613
+}
 pub(crate) mod boolean_set_unconstrained {
-615
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct BooleanSetUnconstrained(pub(crate) std::vec::Vec<bool>);
-619
     impl From<BooleanSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::BooleanSet>
-622
+    {
         fn from(value: BooleanSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-625
+        }
-626
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<BooleanSetUnconstrained> for crate::model::BooleanSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::boolean_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: BooleanSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-638
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-640
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-643
+}
 pub(crate) mod blob_set_unconstrained {
-645
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct BlobSetUnconstrained(pub(crate) std::vec::Vec<::aws_smithy_types::Blob>);
-649
     impl From<BlobSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::BlobSet> {
         fn from(value: BlobSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-653
+        }
-654
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<BlobSetUnconstrained> for crate::model::BlobSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::blob_set::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: BlobSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:185 */
             let inner = value.0;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-666
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-668
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-671
+}
 pub(crate) mod pattern_union_override_unconstrained {
-673
     /* UnconstrainedUnionGenerator.kt:82 */
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum PatternUnionOverrideUnconstrained {
         First(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */ First(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */
         Second(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:82 */
-682
+    }
     /* UnconstrainedUnionGenerator.kt:103 */
     impl ::std::convert::TryFrom<PatternUnionOverrideUnconstrained>
         for crate::model::PatternUnionOverride
-686
+    {
         type Error = crate::model::pattern_union_override::ConstraintViolation;
-688
         fn try_from(
             value: PatternUnionOverrideUnconstrained,
         ) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::pattern_union_override_unconstrained::PatternUnionOverrideUnconstrained::First(unconstrained) => Self::First(
                 unconstrained
                                         .try_into()
-697
-698
                                         .map_err(Self::Error::First)?
             ),
             crate::unconstrained::pattern_union_override_unconstrained::PatternUnionOverrideUnconstrained::Second(unconstrained) => Self::Second(
                 unconstrained
                                         .try_into()
-704
-705
                                         .map_err(Self::Error::Second)?
             ),
-708
+        }
-709
+    )
-710
+        }
-711
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-714
+}
 pub(crate) mod pattern_map_override_unconstrained {
-716
     /* UnconstrainedMapGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct PatternMapOverrideUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-722
     impl From<PatternMapOverrideUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::pattern_map_override_constrained::PatternMapOverrideConstrained,
-726
+        >
-727
+    {
         fn from(value: PatternMapOverrideUnconstrained) -> Self {
             Self::Unconstrained(value)
-730
+        }
-731
+    }
     /* UnconstrainedMapGenerator.kt:101 */
     impl std::convert::TryFrom<PatternMapOverrideUnconstrained>
         for crate::constrained::pattern_map_override_constrained::PatternMapOverrideConstrained
-735
+    {
         /* UnconstrainedMapGenerator.kt:102 */
         type Error = crate::model::pattern_map_override::ConstraintViolation;
         /* UnconstrainedMapGenerator.kt:104 */
         fn try_from(
             value: PatternMapOverrideUnconstrained,
         ) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedMapGenerator.kt:186 */
             let res: ::std::result::Result<
                 ::std::collections::HashMap<
                     crate::model::pattern_map_override::Key,
                     crate::model::pattern_map_override::Value,
                 >,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| {
                     let k: crate::model::pattern_map_override::Key =
                         k.try_into().map_err(Self::Error::Key)?;
-755
                     match crate::model::pattern_map_override::Value::try_from(v) {
                         Ok(v) => Ok((k, v)),
                         Err(inner_constraint_violation) => {
                             Err(Self::Error::Value(k, inner_constraint_violation))
-760
+                        }
-761
+                    }
                 })
                 .collect();
             let hm = res?;
             /* UnconstrainedMapGenerator.kt:247 */
             Ok(Self(hm))
             /* UnconstrainedMapGenerator.kt:104 */
-768
+        }
         /* UnconstrainedMapGenerator.kt:101 */
-770
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-773
+}
 pub(crate) mod pattern_list_override_unconstrained {
-775
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct PatternListOverrideUnconstrained(
         pub(crate) std::vec::Vec<::std::string::String>,
     );
-781
     impl From<PatternListOverrideUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::pattern_list_override_constrained::PatternListOverrideConstrained,
-785
+        >
-786
+    {
         fn from(value: PatternListOverrideUnconstrained) -> Self {
             Self::Unconstrained(value)
-789
+        }
-790
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<PatternListOverrideUnconstrained>
         for crate::constrained::pattern_list_override_constrained::PatternListOverrideConstrained
-794
+    {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::pattern_list_override::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(
             value: PatternListOverrideUnconstrained,
         ) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::pattern_list_override::Member>,
-804
+                (
                     usize,
                     crate::model::pattern_list_override::member::ConstraintViolation,
                 ),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:191 */
             Ok(Self(inner))
             /* UnconstrainedCollectionGenerator.kt:100 */
-823
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-825
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-828
+}
 pub(crate) mod pattern_union_unconstrained {
-830
     /* UnconstrainedUnionGenerator.kt:82 */
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum PatternUnionUnconstrained {
         First(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */ First(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */
         Second(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:82 */
-839
+    }
     /* UnconstrainedUnionGenerator.kt:103 */
     impl ::std::convert::TryFrom<PatternUnionUnconstrained> for crate::model::PatternUnion {
         type Error = crate::model::pattern_union::ConstraintViolation;
-843
         fn try_from(value: PatternUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::pattern_union_unconstrained::PatternUnionUnconstrained::First(unconstrained) => Self::First(
                 unconstrained
                                         .try_into()
-850
-851
                                         .map_err(Self::Error::First)?
             ),
             crate::unconstrained::pattern_union_unconstrained::PatternUnionUnconstrained::Second(unconstrained) => Self::Second(
                 unconstrained
                                         .try_into()
-857
-858
                                         .map_err(Self::Error::Second)?
             ),
-861
+        }
-862
+    )
-863
+        }
-864
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-867
+}
 pub(crate) mod pattern_map_unconstrained {
-869
     /* UnconstrainedMapGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct PatternMapUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-875
     impl From<PatternMapUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::pattern_map_constrained::PatternMapConstrained,
-879
+        >
-880
+    {
         fn from(value: PatternMapUnconstrained) -> Self {
             Self::Unconstrained(value)
-883
+        }
-884
+    }
     /* UnconstrainedMapGenerator.kt:101 */
     impl std::convert::TryFrom<PatternMapUnconstrained>
         for crate::constrained::pattern_map_constrained::PatternMapConstrained
-888
+    {
         /* UnconstrainedMapGenerator.kt:102 */
         type Error = crate::model::pattern_map::ConstraintViolation;
         /* UnconstrainedMapGenerator.kt:104 */
         fn try_from(value: PatternMapUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedMapGenerator.kt:186 */
             let res: ::std::result::Result<
                 ::std::collections::HashMap<
                     crate::model::PatternString,
                     crate::model::PatternString,
                 >,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| {
                     let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
-905
                     match crate::model::PatternString::try_from(v) {
                         Ok(v) => Ok((k, v)),
                         Err(inner_constraint_violation) => {
                             Err(Self::Error::Value(k, inner_constraint_violation))
-910
+                        }
-911
+                    }
                 })
                 .collect();
             let hm = res?;
             /* UnconstrainedMapGenerator.kt:247 */
             Ok(Self(hm))
             /* UnconstrainedMapGenerator.kt:104 */
-918
+        }
         /* UnconstrainedMapGenerator.kt:101 */
-920
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-923
+}
 pub(crate) mod pattern_list_unconstrained {
-925
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct PatternListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-929
     impl From<PatternListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::pattern_list_constrained::PatternListConstrained,
-933
+        >
-934
+    {
         fn from(value: PatternListUnconstrained) -> Self {
             Self::Unconstrained(value)
-937
+        }
-938
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<PatternListUnconstrained>
         for crate::constrained::pattern_list_constrained::PatternListConstrained
-942
+    {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::pattern_list::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: PatternListUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::PatternString>,
                 (usize, crate::model::pattern_string::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:191 */
             Ok(Self(inner))
             /* UnconstrainedCollectionGenerator.kt:100 */
-966
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-968
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-971
+}
 pub(crate) mod length_list_unconstrained {
-973
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct LengthListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-977
     impl From<LengthListUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::LengthList>
-980
+    {
         fn from(value: LengthListUnconstrained) -> Self {
             Self::Unconstrained(value)
-983
+        }
-984
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<LengthListUnconstrained> for crate::model::LengthList {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::length_list::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: LengthListUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::LengthString>,
                 (usize, crate::model::length_string::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-1010
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-1012
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1015
+}
 pub(crate) mod length_map_unconstrained {
-1017
     /* UnconstrainedMapGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct LengthMapUnconstrained(
         pub(crate)  std::collections::HashMap<
             ::std::string::String,
             crate::unconstrained::length_list_unconstrained::LengthListUnconstrained,
         >,
     );
-1026
     impl From<LengthMapUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::LengthMap>
-1029
+    {
         fn from(value: LengthMapUnconstrained) -> Self {
             Self::Unconstrained(value)
-1032
+        }
-1033
+    }
     /* UnconstrainedMapGenerator.kt:101 */
     impl std::convert::TryFrom<LengthMapUnconstrained> for crate::model::LengthMap {
         /* UnconstrainedMapGenerator.kt:102 */
         type Error = crate::model::length_map::ConstraintViolation;
         /* UnconstrainedMapGenerator.kt:104 */
         fn try_from(value: LengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedMapGenerator.kt:186 */
             let res: ::std::result::Result<
                 ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthList>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| {
                     let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
-1049
                     match crate::model::LengthList::try_from(v) {
                         Ok(v) => Ok((k, v)),
                         Err(inner_constraint_violation) => {
                             Err(Self::Error::Value(k, inner_constraint_violation))
-1054
+                        }
-1055
+                    }
                 })
                 .collect();
             let hm = res?;
             /* UnconstrainedMapGenerator.kt:245 */
             Self::try_from(hm)
             /* UnconstrainedMapGenerator.kt:104 */
-1062
+        }
         /* UnconstrainedMapGenerator.kt:101 */
-1064
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1067
+}
 pub(crate) mod enum_union_unconstrained {
-1069
     /* UnconstrainedUnionGenerator.kt:82 */
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum EnumUnionUnconstrained {
         First(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */ First(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */
         Second(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:82 */
-1078
+    }
     /* UnconstrainedUnionGenerator.kt:103 */
     impl ::std::convert::TryFrom<EnumUnionUnconstrained> for crate::model::EnumUnion {
         type Error = crate::model::enum_union::ConstraintViolation;
-1082
         fn try_from(value: EnumUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
             Ok(match value {
                 crate::unconstrained::enum_union_unconstrained::EnumUnionUnconstrained::First(
                     unconstrained,
                 ) => Self::First(unconstrained.try_into().map_err(Self::Error::First)?),
                 crate::unconstrained::enum_union_unconstrained::EnumUnionUnconstrained::Second(
                     unconstrained,
                 ) => Self::Second(unconstrained.try_into().map_err(Self::Error::Second)?),
             })
-1092
+        }
-1093
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1096
+}
 pub(crate) mod enum_map_unconstrained {
-1098
     /* UnconstrainedMapGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct EnumMapUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-1104
     impl From<EnumMapUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::enum_map_constrained::EnumMapConstrained,
-1108
+        >
-1109
+    {
         fn from(value: EnumMapUnconstrained) -> Self {
             Self::Unconstrained(value)
-1112
+        }
-1113
+    }
     /* UnconstrainedMapGenerator.kt:101 */
     impl std::convert::TryFrom<EnumMapUnconstrained>
         for crate::constrained::enum_map_constrained::EnumMapConstrained
-1117
+    {
         /* UnconstrainedMapGenerator.kt:102 */
         type Error = crate::model::enum_map::ConstraintViolation;
         /* UnconstrainedMapGenerator.kt:104 */
         fn try_from(value: EnumMapUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedMapGenerator.kt:186 */
             let res: ::std::result::Result<
                 ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| {
                     let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
-1131
                     match crate::model::EnumString::try_from(v) {
                         Ok(v) => Ok((k, v)),
                         Err(inner_constraint_violation) => {
                             Err(Self::Error::Value(k, inner_constraint_violation))
-1136
+                        }
-1137
+                    }
                 })
                 .collect();
             let hm = res?;
             /* UnconstrainedMapGenerator.kt:247 */
             Ok(Self(hm))
             /* UnconstrainedMapGenerator.kt:104 */
-1144
+        }
         /* UnconstrainedMapGenerator.kt:101 */
-1146
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1149
+}
 pub(crate) mod enum_list_unconstrained {
-1151
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct EnumListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-1155
     impl From<EnumListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::enum_list_constrained::EnumListConstrained,
-1159
+        >
-1160
+    {
         fn from(value: EnumListUnconstrained) -> Self {
             Self::Unconstrained(value)
-1163
+        }
-1164
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<EnumListUnconstrained>
         for crate::constrained::enum_list_constrained::EnumListConstrained
-1168
+    {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::enum_list::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: EnumListUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::EnumString>,
                 (usize, crate::model::enum_string::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:191 */
             Ok(Self(inner))
             /* UnconstrainedCollectionGenerator.kt:100 */
-1192
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-1194
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1197
+}

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

@@ -1,1 +113,125 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 pub(crate) mod sparse_set_map_constrained {
-4
     /* PubCrateConstrainedMapGenerator.kt:80 */
     #[derive(Debug, Clone)]
     pub(crate) struct SparseSetMapConstrained(
         pub(crate)  std::collections::HashMap<
             ::std::string::String,
             ::std::option::Option<crate::model::StringSet>,
         >,
     );
-13
     impl crate::constrained::Constrained for SparseSetMapConstrained {
         type Unconstrained =
             crate::unconstrained::sparse_set_map_unconstrained::SparseSetMapUnconstrained;
-17
+    }
     /* PubCrateConstrainedMapGenerator.kt:99 */
     impl
         ::std::convert::From<
             ::std::collections::HashMap<
                 ::std::string::String,
                 ::std::option::Option<crate::model::StringSet>,
             >,
         > for SparseSetMapConstrained
-26
+    {
         fn from(
             v: ::std::collections::HashMap<
                 ::std::string::String,
                 ::std::option::Option<crate::model::StringSet>,
             >,
         ) -> Self {
             Self(v)
-34
+        }
-35
+    }
-36
     impl ::std::convert::From<SparseSetMapConstrained>
         for ::std::collections::HashMap<
             ::std::string::String,
             ::std::option::Option<crate::model::StringSet>,
-41
+        >
-42
+    {
         fn from(v: SparseSetMapConstrained) -> Self {
             v.0
-45
+        }
-46
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-49
+}
 pub(crate) mod dense_set_map_constrained {
-51
     /* PubCrateConstrainedMapGenerator.kt:80 */
     #[derive(Debug, Clone)]
     pub(crate) struct DenseSetMapConstrained(
         pub(crate) std::collections::HashMap<::std::string::String, crate::model::StringSet>,
     );
-57
     impl crate::constrained::Constrained for DenseSetMapConstrained {
         type Unconstrained =
             crate::unconstrained::dense_set_map_unconstrained::DenseSetMapUnconstrained;
-61
+    }
     /* PubCrateConstrainedMapGenerator.kt:99 */
     impl
         ::std::convert::From<
             ::std::collections::HashMap<::std::string::String, crate::model::StringSet>,
         > for DenseSetMapConstrained
-67
+    {
         fn from(
             v: ::std::collections::HashMap<::std::string::String, crate::model::StringSet>,
         ) -> Self {
             Self(v)
-72
+        }
-73
+    }
-74
     impl ::std::convert::From<DenseSetMapConstrained>
         for ::std::collections::HashMap<::std::string::String, crate::model::StringSet>
-77
+    {
         fn from(v: DenseSetMapConstrained) -> Self {
             v.0
-80
+        }
-81
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-84
+}
 pub(crate) mod foo_enum_list_constrained {
-86
     /* PubCrateConstrainedCollectionGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumListConstrained(pub(crate) std::vec::Vec<crate::model::FooEnum>);
-90
     impl crate::constrained::Constrained for FooEnumListConstrained {
         type Unconstrained =
             crate::unconstrained::foo_enum_list_unconstrained::FooEnumListUnconstrained;
-94
+    }
     /* PubCrateConstrainedCollectionGenerator.kt:108 */
     impl ::std::convert::From<::std::vec::Vec<crate::model::FooEnum>> for FooEnumListConstrained {
         fn from(v: ::std::vec::Vec<crate::model::FooEnum>) -> Self {
             Self(v)
-99
+        }
-100
+    }
-101
     impl ::std::convert::From<FooEnumListConstrained> for ::std::vec::Vec<crate::model::FooEnum> {
         fn from(v: FooEnumListConstrained) -> Self {
             v.0
-105
+        }
-106
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-109
+}
-110
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-115
 pub(crate) trait Constrained {
     type Unconstrained;
-118
+}

↧ Expand context

-119
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub(crate) enum MaybeConstrained<T: Constrained> {
     Constrained(T),
     Unconstrained(T::Unconstrained),
-125
+}

Server Test

Files changed: