Client Test

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_defaults.rs

@@ -155,155 +401,401 @@

     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_byte(&self) -> i8 {
         self.zero_byte
-158
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_short(&self) -> i16 {
         self.zero_short
-162
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_integer(&self) -> i32 {
         self.zero_integer
-166
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_long(&self) -> i64 {
         self.zero_long
-170
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_float(&self) -> f32 {
         self.zero_float
-174
+    }

     #[allow(missing_docs)] // documentation missing in model
     pub fn zero_double(&self) -> f64 {
         self.zero_double
-178
+    }
-179
+}
 static DEFAULTS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults", "aws.protocoltests.json10", "Defaults");
 static DEFAULTS_MEMBER_DEFAULT_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultString", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::String,
     "default_string",
     "defaultString",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultBoolean", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "default_boolean",
     "defaultBoolean",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultList", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::List,
     "default_list",
     "defaultList",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_DOCUMENT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#Defaults$defaultDocumentMap",
         "aws.protocoltests.json10",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "default_document_map",
     "defaultDocumentMap",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_DOCUMENT_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#Defaults$defaultDocumentString",
         "aws.protocoltests.json10",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "default_document_string",
     "defaultDocumentString",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_DOCUMENT_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#Defaults$defaultDocumentBoolean",
         "aws.protocoltests.json10",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "default_document_boolean",
     "defaultDocumentBoolean",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_DOCUMENT_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#Defaults$defaultDocumentList",
         "aws.protocoltests.json10",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "default_document_list",
     "defaultDocumentList",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_NULL_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#Defaults$defaultNullDocument",
         "aws.protocoltests.json10",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "default_null_document",
     "defaultNullDocument",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#Defaults$defaultTimestamp",
         "aws.protocoltests.json10",
         "Defaults",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "default_timestamp",
     "defaultTimestamp",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultBlob", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Blob,
     "default_blob",
     "defaultBlob",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultByte", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Byte,
     "default_byte",
     "defaultByte",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultShort", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Short,
     "default_short",
     "defaultShort",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultInteger", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Integer,
     "default_integer",
     "defaultInteger",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultLong", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Long,
     "default_long",
     "defaultLong",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultFloat", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Float,
     "default_float",
     "defaultFloat",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultDouble", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Double,
     "default_double",
     "defaultDouble",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultMap", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Map,
     "default_map",
     "defaultMap",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultEnum", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::String,
     "default_enum",
     "defaultEnum",
 ,
 );
 static DEFAULTS_MEMBER_DEFAULT_INT_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$defaultIntEnum", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Integer,
     "default_int_enum",
     "defaultIntEnum",
 ,
 );
 static DEFAULTS_MEMBER_EMPTY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$emptyString", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::String,
     "empty_string",
     "emptyString",
 ,
 );
 static DEFAULTS_MEMBER_FALSE_BOOLEAN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$falseBoolean", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "false_boolean",
     "falseBoolean",
 ,
 );
 static DEFAULTS_MEMBER_EMPTY_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$emptyBlob", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Blob,
     "empty_blob",
     "emptyBlob",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_BYTE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$zeroByte", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Byte,
     "zero_byte",
     "zeroByte",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_SHORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$zeroShort", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Short,
     "zero_short",
     "zeroShort",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_INTEGER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$zeroInteger", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Integer,
     "zero_integer",
     "zeroInteger",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_LONG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$zeroLong", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Long,
     "zero_long",
     "zeroLong",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_FLOAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$zeroFloat", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Float,
     "zero_float",
     "zeroFloat",
 ,
 );
 static DEFAULTS_MEMBER_ZERO_DOUBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Defaults$zeroDouble", "aws.protocoltests.json10", "Defaults"),
     ::aws_smithy_schema::ShapeType::Double,
     "zero_double",
     "zeroDouble",
 ,
 );
 static DEFAULTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DEFAULTS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DEFAULTS_MEMBER_DEFAULT_STRING,
         &DEFAULTS_MEMBER_DEFAULT_BOOLEAN,
         &DEFAULTS_MEMBER_DEFAULT_LIST,
         &DEFAULTS_MEMBER_DEFAULT_DOCUMENT_MAP,

↧ Expand context

         &DEFAULTS_MEMBER_DEFAULT_DOCUMENT_STRING,
         &DEFAULTS_MEMBER_DEFAULT_DOCUMENT_BOOLEAN,
         &DEFAULTS_MEMBER_DEFAULT_DOCUMENT_LIST,
         &DEFAULTS_MEMBER_DEFAULT_NULL_DOCUMENT,
         &DEFAULTS_MEMBER_DEFAULT_TIMESTAMP,
         &DEFAULTS_MEMBER_DEFAULT_BLOB,
         &DEFAULTS_MEMBER_DEFAULT_BYTE,
         &DEFAULTS_MEMBER_DEFAULT_SHORT,
         &DEFAULTS_MEMBER_DEFAULT_INTEGER,
         &DEFAULTS_MEMBER_DEFAULT_LONG,
         &DEFAULTS_MEMBER_DEFAULT_FLOAT,
         &DEFAULTS_MEMBER_DEFAULT_DOUBLE,
         &DEFAULTS_MEMBER_DEFAULT_MAP,
         &DEFAULTS_MEMBER_DEFAULT_ENUM,
         &DEFAULTS_MEMBER_DEFAULT_INT_ENUM,
         &DEFAULTS_MEMBER_EMPTY_STRING,
         &DEFAULTS_MEMBER_FALSE_BOOLEAN,
         &DEFAULTS_MEMBER_EMPTY_BLOB,
         &DEFAULTS_MEMBER_ZERO_BYTE,
         &DEFAULTS_MEMBER_ZERO_SHORT,

@@ -523,523 +707,698 @@

↥ Expand context

-523
+        }
-524
+        {
             let val = &self.zero_byte;
             ser.write_byte(&DEFAULTS_MEMBER_ZERO_BYTE, *val)?;
-527
+        }
-528
+        {
             let val = &self.zero_short;
             ser.write_short(&DEFAULTS_MEMBER_ZERO_SHORT, *val)?;
-531
+        }
-532
+        {
             let val = &self.zero_integer;
             ser.write_integer(&DEFAULTS_MEMBER_ZERO_INTEGER, *val)?;
-535
+        }
-536
+        {
             let val = &self.zero_long;
             ser.write_long(&DEFAULTS_MEMBER_ZERO_LONG, *val)?;
-539
+        }
-540
+        {
             let val = &self.zero_float;
             ser.write_float(&DEFAULTS_MEMBER_ZERO_FLOAT, *val)?;

-543
+        }
-544
+        {
             let val = &self.zero_double;
             ser.write_double(&DEFAULTS_MEMBER_ZERO_DOUBLE, *val)?;
-547
+        }
         Ok(())
-549
+    }
-550
+}
 impl Defaults {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&DEFAULTS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DEFAULTS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.default_string = Some(deser.read_string(member)?);
-569
+                }
                 Some(1) => {
                     builder.default_boolean = Some(deser.read_boolean(member)?);
-572
+                }
                 Some(2) => {
                     builder.default_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.default_list = Some(deser.read_string_list(member)?);
-575
+                }
                 Some(3) => {
                     builder.default_document_map = Some(deser.read_document(member)?);
-578
+                }
                 Some(4) => {
                     builder.default_document_string = Some(deser.read_document(member)?);
-581
+                }
                 Some(5) => {
                     builder.default_document_boolean = Some(deser.read_document(member)?);
-584
+                }
                 Some(6) => {
                     builder.default_document_list = Some(deser.read_document(member)?);
-587
+                }
                 Some(7) => {
                     builder.default_null_document = Some(deser.read_document(member)?);
-590
+                }
                 Some(8) => {
                     builder.default_timestamp = Some(deser.read_timestamp(member)?);
-593
+                }
                 Some(9) => {
                     builder.default_blob = Some(deser.read_blob(member)?);
-596
+                }
                 Some(10) => {
                     builder.default_byte = Some(deser.read_byte(member)?);
-599
+                }
                 Some(11) => {
                     builder.default_short = Some(deser.read_short(member)?);
-602
+                }
                 Some(12) => {
                     builder.default_integer = Some(deser.read_integer(member)?);
-605
+                }
                 Some(13) => {
                     builder.default_long = Some(deser.read_long(member)?);
-608
+                }
                 Some(14) => {
                     builder.default_float = Some(deser.read_float(member)?);
-611
+                }
                 Some(15) => {
                     builder.default_double = Some(deser.read_double(member)?);
-614
+                }
                 Some(16) => {
                     builder.default_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.default_map = Some(deser.read_string_string_map(member)?);
-617
+                }
                 Some(17) => {
                     builder.default_enum = Some(crate::types::TestEnum::from(deser.read_string(member)?.as_str()));
-620
+                }
                 Some(18) => {
                     builder.default_int_enum = Some(deser.read_integer(member)?);
-623
+                }
                 Some(19) => {
                     builder.empty_string = Some(deser.read_string(member)?);
-626
+                }
                 Some(20) => {
                     builder.false_boolean = Some(deser.read_boolean(member)?);
-629
+                }
                 Some(21) => {
                     builder.empty_blob = Some(deser.read_blob(member)?);
-632
+                }
                 Some(22) => {
                     builder.zero_byte = Some(deser.read_byte(member)?);
-635
+                }
                 Some(23) => {
                     builder.zero_short = Some(deser.read_short(member)?);
-638
+                }
                 Some(24) => {
                     builder.zero_integer = Some(deser.read_integer(member)?);
-641
+                }
                 Some(25) => {
                     builder.zero_long = Some(deser.read_long(member)?);
-644
+                }
                 Some(26) => {
                     builder.zero_float = Some(deser.read_float(member)?);
-647
+                }
                 Some(27) => {
                     builder.zero_double = Some(deser.read_double(member)?);
-650
+                }
                 _ => {}
-652
+            }
             Ok(())
         })?;
         Ok(builder.build())
-656
+    }
-657
+}
 impl Defaults {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Defaults {
     /// Creates a new builder-style object to manufacture [`Defaults`](crate::types::Defaults).
     pub fn builder() -> crate::types::builders::DefaultsBuilder {
         crate::types::builders::DefaultsBuilder::default()
-673
+    }
-674
+}
-675
 /// A builder for [`Defaults`](crate::types::Defaults).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DefaultsBuilder {
     pub(crate) default_string: ::std::option::Option<::std::string::String>,
     pub(crate) default_boolean: ::std::option::Option<bool>,
     pub(crate) default_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) default_document_map: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) default_document_string: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) default_document_boolean: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) default_document_list: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) default_null_document: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) default_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) default_blob: ::std::option::Option<::aws_smithy_types::Blob>,
     pub(crate) default_byte: ::std::option::Option<i8>,
     pub(crate) default_short: ::std::option::Option<i16>,
     pub(crate) default_integer: ::std::option::Option<i32>,
     pub(crate) default_long: ::std::option::Option<i64>,
     pub(crate) default_float: ::std::option::Option<f32>,
     pub(crate) default_double: ::std::option::Option<f64>,
     pub(crate) default_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) default_enum: ::std::option::Option<crate::types::TestEnum>,
     pub(crate) default_int_enum: ::std::option::Option<i32>,

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_dialog.rs

@@ -48,48 +137,148 @@

↥ Expand context

 static DIALOG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     DIALOG_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DIALOG_MEMBER_LANGUAGE, &DIALOG_MEMBER_GREETING, &DIALOG_MEMBER_FAREWELL],
 );
 impl Dialog {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DIALOG_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Dialog {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.language {
             ser.write_string(&DIALOG_MEMBER_LANGUAGE, val)?;
-65
+        }
-66
+        {
             let val = &self.greeting;

             ser.write_string(&DIALOG_MEMBER_GREETING, val)?;
-69
+        }
         if let Some(ref val) = self.farewell {
             ser.write_struct(&DIALOG_MEMBER_FAREWELL, val)?;
-72
+        }
         Ok(())
-74
+    }
-75
+}
 impl Dialog {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&DIALOG_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&DIALOG_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.language = Some(deser.read_string(member)?);
-94
+                }
                 Some(1) => {
                     builder.greeting = Some(deser.read_string(member)?);
-97
+                }
                 Some(2) => {
                     builder.farewell = Some(crate::types::Farewell::deserialize(deser)?);
-100
+                }
                 _ => {}
-102
+            }
             Ok(())
         })?;
         Ok(builder.build())
-106
+    }
-107
+}
 impl Dialog {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Dialog {
     /// Creates a new builder-style object to manufacture [`Dialog`](crate::types::Dialog).
     pub fn builder() -> crate::types::builders::DialogBuilder {
         crate::types::builders::DialogBuilder::default()
-123
+    }
-124
+}
-125
 /// A builder for [`Dialog`](crate::types::Dialog).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct DialogBuilder {
     pub(crate) language: ::std::option::Option<::std::string::String>,
     pub(crate) greeting: ::std::option::Option<::std::string::String>,
     pub(crate) farewell: ::std::option::Option<crate::types::Farewell>,
-133
+}
 impl DialogBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn language(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.language = ::std::option::Option::Some(input.into());
         self
-139
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_language(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.language = input;
         self
-144
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_language(&self) -> &::std::option::Option<::std::string::String> {
         &self.language
-148
+    }

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_farewell.rs

@@ -15,15 +98,109 @@

↥ Expand context

-15
+}
 static FAREWELL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Farewell", "aws.protocoltests.json10", "Farewell");
 static FAREWELL_MEMBER_PHRASE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#Farewell$phrase", "aws.protocoltests.json10", "Farewell"),
     ::aws_smithy_schema::ShapeType::String,
     "phrase",
 ,
 );
 static FAREWELL_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(FAREWELL_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[&FAREWELL_MEMBER_PHRASE]);
 impl Farewell {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FAREWELL_SCHEMA;
-29
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Farewell {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,

     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-36
+        {
             let val = &self.phrase;
             ser.write_string(&FAREWELL_MEMBER_PHRASE, val)?;
-39
+        }
         Ok(())
-41
+    }
-42
+}
 impl Farewell {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&FAREWELL_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FAREWELL_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.phrase = Some(deser.read_string(member)?);
-61
+                }
                 _ => {}
-63
+            }
             Ok(())
         })?;
         Ok(builder.build())
-67
+    }
-68
+}
 impl Farewell {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Farewell {
     /// Creates a new builder-style object to manufacture [`Farewell`](crate::types::Farewell).
     pub fn builder() -> crate::types::builders::FarewellBuilder {
         crate::types::builders::FarewellBuilder::default()
-84
+    }
-85
+}
-86
 /// A builder for [`Farewell`](crate::types::Farewell).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct FarewellBuilder {
     pub(crate) phrase: ::std::option::Option<::std::string::String>,
-92
+}
 impl FarewellBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn phrase(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.phrase = ::std::option::Option::Some(input.into());
         self
-98
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_phrase(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.phrase = input;
         self
-103
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_phrase(&self) -> &::std::option::Option<::std::string::String> {
         &self.phrase
-107
+    }
     /// Consumes the builder and constructs a [`Farewell`](crate::types::Farewell).
     pub fn build(self) -> crate::types::Farewell {

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_greeting_struct.rs

@@ -16,16 +99,110 @@

↥ Expand context

     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.shared#GreetingStruct", "aws.protocoltests.shared", "GreetingStruct");
 static GREETINGSTRUCT_MEMBER_HI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.shared#GreetingStruct$hi", "aws.protocoltests.shared", "GreetingStruct"),
     ::aws_smithy_schema::ShapeType::String,
     "hi",
 ,
 );
 static GREETINGSTRUCT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GREETINGSTRUCT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GREETINGSTRUCT_MEMBER_HI],
 );
 impl GreetingStruct {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GREETINGSTRUCT_SCHEMA;
-31
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GreetingStruct {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.hi {
             ser.write_string(&GREETINGSTRUCT_MEMBER_HI, val)?;
-40
+        }
         Ok(())
-42
+    }
-43
+}
 impl GreetingStruct {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&GREETINGSTRUCT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GREETINGSTRUCT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hi = Some(deser.read_string(member)?);
-62
+                }
                 _ => {}
-64
+            }
             Ok(())
         })?;
         Ok(builder.build())
-68
+    }
-69
+}
 impl GreetingStruct {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GreetingStruct {
     /// Creates a new builder-style object to manufacture [`GreetingStruct`](crate::types::GreetingStruct).
     pub fn builder() -> crate::types::builders::GreetingStructBuilder {
         crate::types::builders::GreetingStructBuilder::default()
-85
+    }
-86
+}
-87
 /// A builder for [`GreetingStruct`](crate::types::GreetingStruct).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GreetingStructBuilder {
     pub(crate) hi: ::std::option::Option<::std::string::String>,
-93
+}
 impl GreetingStructBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn hi(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.hi = ::std::option::Option::Some(input.into());
         self
-99
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_hi(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.hi = input;
         self
-104
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_hi(&self) -> &::std::option::Option<::std::string::String> {
         &self.hi
-108
+    }
     /// Consumes the builder and constructs a [`GreetingStruct`](crate::types::GreetingStruct).
     pub fn build(self) -> crate::types::GreetingStruct {

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_my_union.rs

@@ -143,143 +0,322 @@

↥ Expand context

     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_structure_value(&self) -> ::std::result::Result<&crate::types::GreetingStruct, &Self> {
         if let MyUnion::StructureValue(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-149
+        }
-150
+    }
     /// Returns true if this is a [`StructureValue`](crate::types::MyUnion::StructureValue).
     pub fn is_structure_value(&self) -> bool {
         self.as_structure_value().is_ok()
-154
+    }
     /// Tries to convert the enum instance into [`TimestampValue`](crate::types::MyUnion::TimestampValue), extracting the inner [`DateTime`](::aws_smithy_types::DateTime).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_timestamp_value(&self) -> ::std::result::Result<&::aws_smithy_types::DateTime, &Self> {
         if let MyUnion::TimestampValue(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-162
+        }

-163
+    }
     /// Returns true if this is a [`TimestampValue`](crate::types::MyUnion::TimestampValue).
     pub fn is_timestamp_value(&self) -> bool {
         self.as_timestamp_value().is_ok()
-167
+    }
     /// Returns true if the enum instance is the `Unknown` variant.
     pub fn is_unknown(&self) -> bool {
         matches!(self, Self::Unknown)
-171
+    }
-172
+}
 static MYUNION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion", "aws.protocoltests.json10", "MyUnion");
 static MYUNION_MEMBER_STRINGVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$stringValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::String,
     "stringValue",
 ,
 );
 static MYUNION_MEMBER_BOOLEANVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$booleanValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Boolean,
     "booleanValue",
 ,
 );
 static MYUNION_MEMBER_NUMBERVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$numberValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Integer,
     "numberValue",
 ,
 );
 static MYUNION_MEMBER_BLOBVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$blobValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Blob,
     "blobValue",
 ,
 );
 static MYUNION_MEMBER_TIMESTAMPVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$timestampValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "timestampValue",
 ,
 );
 static MYUNION_MEMBER_ENUMVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$enumValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::String,
     "enumValue",
 ,
 );
 static MYUNION_MEMBER_INTENUMVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$intEnumValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Integer,
     "intEnumValue",
 ,
 );
 static MYUNION_MEMBER_LISTVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$listValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::List,
     "listValue",
 ,
 );
 static MYUNION_MEMBER_MAPVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$mapValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Map,
     "mapValue",
 ,
 );
 static MYUNION_MEMBER_STRUCTUREVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#MyUnion$structureValue", "aws.protocoltests.json10", "MyUnion"),
     ::aws_smithy_schema::ShapeType::Structure,
     "structureValue",
 ,
 );
 static MYUNION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     MYUNION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Union,
     &[
         &MYUNION_MEMBER_STRINGVALUE,
         &MYUNION_MEMBER_BOOLEANVALUE,
         &MYUNION_MEMBER_NUMBERVALUE,
         &MYUNION_MEMBER_BLOBVALUE,
         &MYUNION_MEMBER_TIMESTAMPVALUE,
         &MYUNION_MEMBER_ENUMVALUE,
         &MYUNION_MEMBER_INTENUMVALUE,
         &MYUNION_MEMBER_LISTVALUE,
         &MYUNION_MEMBER_MAPVALUE,
         &MYUNION_MEMBER_STRUCTUREVALUE,
     ],
 );
 impl MyUnion {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MYUNION_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for MyUnion {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         match self {
             Self::StringValue(val) => {
                 ser.write_string(&MYUNION_MEMBER_STRINGVALUE, val)?;
-+
+            }
             Self::BooleanValue(val) => {
                 ser.write_boolean(&MYUNION_MEMBER_BOOLEANVALUE, *val)?;
-+
+            }
             Self::NumberValue(val) => {
                 ser.write_integer(&MYUNION_MEMBER_NUMBERVALUE, *val)?;
-+
+            }
             Self::BlobValue(val) => {
                 ser.write_blob(&MYUNION_MEMBER_BLOBVALUE, val)?;
-+
+            }
             Self::TimestampValue(val) => {
                 ser.write_timestamp(&MYUNION_MEMBER_TIMESTAMPVALUE, val)?;
-+
+            }
             Self::EnumValue(val) => {
                 ser.write_string(&MYUNION_MEMBER_ENUMVALUE, val.as_str())?;
-+
+            }
             Self::IntEnumValue(val) => {
                 ser.write_integer(&MYUNION_MEMBER_INTENUMVALUE, *val)?;
-+
+            }
             Self::ListValue(val) => {
                 ser.write_string_list(&MYUNION_MEMBER_LISTVALUE, val)?;
-+
+            }
             Self::MapValue(val) => {
                 ser.write_string_string_map(&MYUNION_MEMBER_MAPVALUE, val)?;
-+
+            }
             Self::StructureValue(val) => {
                 ser.write_struct(&MYUNION_MEMBER_STRUCTUREVALUE, val)?;
-+
+            }
             Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl MyUnion {
     /// Deserializes this union from a [`ShapeDeserializer`].
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         deserializer.read_struct(&MYUNION_SCHEMA, &mut |member, deser| {
             result = ::std::option::Option::Some(match member.member_index() {
                 Some(0) => Self::StringValue(deser.read_string(member)?),
                 Some(1) => Self::BooleanValue(deser.read_boolean(member)?),
                 Some(2) => Self::NumberValue(deser.read_integer(member)?),
                 Some(3) => Self::BlobValue(deser.read_blob(member)?),
                 Some(4) => Self::TimestampValue(deser.read_timestamp(member)?),
                 Some(5) => Self::EnumValue(crate::types::FooEnum::from(deser.read_string(member)?.as_str())),
                 Some(6) => Self::IntEnumValue(deser.read_integer(member)?),
                 Some(7) => Self::ListValue(deser.read_string_list(member)?),
                 Some(8) => Self::MapValue(deser.read_string_string_map(member)?),
                 Some(9) => Self::StructureValue(crate::types::GreetingStruct::deserialize(deser)?),
                 _ => Self::Unknown,
             });
             Ok(())
         })?;
         result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
-+
+    }
-+
+}

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_top_level.rs

@@ -9,9 +180,185 @@

↥ Expand context

     pub dialog_list: ::std::vec::Vec<crate::types::Dialog>,
     #[allow(missing_docs)] // documentation missing in model
     pub dialog_map: ::std::collections::HashMap<::std::string::String, crate::types::Dialog>,
-12
+}
 impl TopLevel {
     #[allow(missing_docs)] // documentation missing in model
     pub fn dialog(&self) -> &crate::types::Dialog {
         &self.dialog
-17
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dialog_list(&self) -> &[crate::types::Dialog] {
         use std::ops::Deref;
         self.dialog_list.deref()
-22
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn dialog_map(&self) -> &::std::collections::HashMap<::std::string::String, crate::types::Dialog> {
         &self.dialog_map
-26
+    }
-27
+}
 static TOPLEVEL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =

     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#TopLevel", "aws.protocoltests.json10", "TopLevel");
 static TOPLEVEL_MEMBER_DIALOG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#TopLevel$dialog", "aws.protocoltests.json10", "TopLevel"),
     ::aws_smithy_schema::ShapeType::Structure,
     "dialog",
 ,
 );
 static TOPLEVEL_MEMBER_DIALOG_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#TopLevel$dialogList", "aws.protocoltests.json10", "TopLevel"),
     ::aws_smithy_schema::ShapeType::List,
     "dialog_list",
     "dialogList",
 ,
 );
 static TOPLEVEL_MEMBER_DIALOG_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#TopLevel$dialogMap", "aws.protocoltests.json10", "TopLevel"),
     ::aws_smithy_schema::ShapeType::Map,
     "dialog_map",
     "dialogMap",
 ,
 );
 static TOPLEVEL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TOPLEVEL_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TOPLEVEL_MEMBER_DIALOG, &TOPLEVEL_MEMBER_DIALOG_LIST, &TOPLEVEL_MEMBER_DIALOG_MAP],
 );
 impl TopLevel {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TOPLEVEL_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TopLevel {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-63
+        {
             let val = &self.dialog;
             ser.write_struct(&TOPLEVEL_MEMBER_DIALOG, val)?;
-66
+        }
-67
+        {
             let val = &self.dialog_list;
-69
             ser.write_list(
                 &TOPLEVEL_MEMBER_DIALOG_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Dialog::SCHEMA, item)?;
-75
+                    }
                     Ok(())
                 },
             )?;
-79
+        }
-80
+        {
             let val = &self.dialog_map;
-82
             ser.write_map(
                 &TOPLEVEL_MEMBER_DIALOG_MAP,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::Dialog::SCHEMA, value)?;
-89
+                    }
                     Ok(())
                 },
             )?;
-93
+        }
         Ok(())
-95
+    }
-96
+}
 impl TopLevel {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&TOPLEVEL_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TOPLEVEL_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dialog = Some(crate::types::Dialog::deserialize(deser)?);
-115
+                }
                 Some(1) => {
                     builder.dialog_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Dialog::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Dialog::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-125
+                }
                 Some(2) => {
                     builder.dialog_map = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::Dialog::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::Dialog::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-135
+                }
                 _ => {}
-137
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-143
+    }
-144
+}
 impl TopLevel {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl TopLevel {
     /// Creates a new builder-style object to manufacture [`TopLevel`](crate::types::TopLevel).
     pub fn builder() -> crate::types::builders::TopLevelBuilder {
         crate::types::builders::TopLevelBuilder::default()
-160
+    }
-161
+}
-162
 /// A builder for [`TopLevel`](crate::types::TopLevel).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TopLevelBuilder {
     pub(crate) dialog: ::std::option::Option<crate::types::Dialog>,
     pub(crate) dialog_list: ::std::option::Option<::std::vec::Vec<crate::types::Dialog>>,
     pub(crate) dialog_map: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::Dialog>>,
-170
+}
 impl TopLevelBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn dialog(mut self, input: crate::types::Dialog) -> Self {
         self.dialog = ::std::option::Option::Some(input);
         self
-177
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_dialog(mut self, input: ::std::option::Option<crate::types::Dialog>) -> Self {
         self.dialog = input;
         self
-182
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_dialog(&self) -> &::std::option::Option<crate::types::Dialog> {
         &self.dialog

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/error/_complex_error.rs

@@ -4,4 +141,152 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ComplexError {
     #[allow(missing_docs)] // documentation missing in model
     pub top_level: ::std::option::Option<::std::string::String>,
     #[allow(missing_docs)] // documentation missing in model
     pub nested: ::std::option::Option<crate::types::ComplexNestedErrorData>,
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-14
+}
 impl ComplexError {
     #[allow(missing_docs)] // documentation missing in model
     pub fn top_level(&self) -> ::std::option::Option<&str> {
         self.top_level.as_deref()
-19
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn nested(&self) -> ::std::option::Option<&crate::types::ComplexNestedErrorData> {
         self.nested.as_ref()
-23
+    }

-24
+}
 static COMPLEXERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#ComplexError", "aws.protocoltests.json10", "ComplexError");
 static COMPLEXERROR_MEMBER_TOP_LEVEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#ComplexError$TopLevel",
         "aws.protocoltests.json10",
         "ComplexError",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "top_level",
     "TopLevel",
 ,
 );
 static COMPLEXERROR_MEMBER_NESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#ComplexError$Nested", "aws.protocoltests.json10", "ComplexError"),
     ::aws_smithy_schema::ShapeType::Structure,
     "nested",
     "Nested",
 ,
 );
 static COMPLEXERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#ComplexError$Message",
         "aws.protocoltests.json10",
         "ComplexError",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static COMPLEXERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COMPLEXERROR_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COMPLEXERROR_MEMBER_TOP_LEVEL, &COMPLEXERROR_MEMBER_NESTED, &COMPLEXERROR_MEMBER_MESSAGE],
 );
 impl ComplexError {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLEXERROR_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ComplexError {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.top_level {
             ser.write_string(&COMPLEXERROR_MEMBER_TOP_LEVEL, val)?;
-70
+        }
         if let Some(ref val) = self.nested {
             ser.write_struct(&COMPLEXERROR_MEMBER_NESTED, val)?;
-73
+        }
         if let Some(ref val) = self.message {
             ser.write_string(&COMPLEXERROR_MEMBER_MESSAGE, val)?;
-76
+        }
         Ok(())
-78
+    }
-79
+}
 impl ComplexError {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&COMPLEXERROR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COMPLEXERROR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.top_level = Some(deser.read_string(member)?);
-98
+                }
                 Some(1) => {
                     builder.nested = Some(crate::types::ComplexNestedErrorData::deserialize(deser)?);
-101
+                }
                 Some(2) => {
                     builder.message = Some(deser.read_string(member)?);
-104
+                }
                 _ => {}
-106
+            }
             Ok(())
         })?;
         Ok(builder.build())
-110
+    }
-111
+}
 impl ComplexError {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ComplexError {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-127
+    }
-128
+}
 impl ::std::fmt::Display for ComplexError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ComplexError")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-133
+            {
                 ::std::write!(f, ": {inner_1}")?;
-135
+            }
-136
+        }
         Ok(())
-138
+    }
-139
+}
 impl ::std::error::Error for ComplexError {}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ComplexError {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-144
+    }
-145
+}
 impl ComplexError {
     /// Creates a new builder-style object to manufacture [`ComplexError`](crate::types::error::ComplexError).
     pub fn builder() -> crate::types::error::builders::ComplexErrorBuilder {
         crate::types::error::builders::ComplexErrorBuilder::default()
-150
+    }
-151
+}
-152

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/error/_foo_error.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// This error has test cases that test some of the dark corners of Amazon service framework history. It should only be implemented by clients.
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

 pub struct FooError {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-10
+}
 static FOOERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#FooError", "aws.protocoltests.json10", "FooError");
 static FOOERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#FooError$Message", "aws.protocoltests.json10", "FooError"),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static FOOERROR_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(FOOERROR_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[&FOOERROR_MEMBER_MESSAGE]);
 impl FooError {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FOOERROR_SCHEMA;
-24
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for FooError {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&FOOERROR_MEMBER_MESSAGE, val)?;
-33
+        }
         Ok(())
-35
+    }
-36
+}
 impl FooError {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&FOOERROR_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&FOOERROR_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-55
+                }
                 _ => {}
-57
+            }
             Ok(())
         })?;
         Ok(builder.build())
-61
+    }
-62
+}
 impl FooError {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl FooError {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-78
+    }
-79
+}
 impl ::std::fmt::Display for FooError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "FooError")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-84
+            {
                 ::std::write!(f, ": {inner_1}")?;
-86
+            }
-87
+        }
         Ok(())
-89
+    }
-90
+}
 impl ::std::error::Error for FooError {}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for FooError {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-95
+    }
-96
+}
 impl FooError {
     /// Creates a new builder-style object to manufacture [`FooError`](crate::types::error::FooError).
     pub fn builder() -> crate::types::error::builders::FooErrorBuilder {
         crate::types::error::builders::FooErrorBuilder::default()
-101
+    }
-102
+}
-103

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/error/_invalid_greeting.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// This error is thrown when an invalid greeting value is provided.
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct InvalidGreeting {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,

-10
+}
 static INVALIDGREETING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.json10#InvalidGreeting", "aws.protocoltests.json10", "InvalidGreeting");
 static INVALIDGREETING_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "aws.protocoltests.json10#InvalidGreeting$Message",
         "aws.protocoltests.json10",
         "InvalidGreeting",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static INVALIDGREETING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INVALIDGREETING_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INVALIDGREETING_MEMBER_MESSAGE],
 );
 impl InvalidGreeting {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDGREETING_SCHEMA;
-31
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InvalidGreeting {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&INVALIDGREETING_MEMBER_MESSAGE, val)?;
-40
+        }
         Ok(())
-42
+    }
-43
+}
 impl InvalidGreeting {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&INVALIDGREETING_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INVALIDGREETING_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-62
+                }
                 _ => {}
-64
+            }
             Ok(())
         })?;
         Ok(builder.build())
-68
+    }
-69
+}
 impl InvalidGreeting {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl InvalidGreeting {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-85
+    }
-86
+}
 impl ::std::fmt::Display for InvalidGreeting {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InvalidGreeting")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-91
+            {
                 ::std::write!(f, ": {inner_1}")?;
-93
+            }
-94
+        }
         Ok(())
-96
+    }
-97
+}
 impl ::std::error::Error for InvalidGreeting {}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for InvalidGreeting {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-102
+    }
-103
+}
 impl InvalidGreeting {
     /// Creates a new builder-style object to manufacture [`InvalidGreeting`](crate::types::error::InvalidGreeting).
     pub fn builder() -> crate::types::error::builders::InvalidGreetingBuilder {
         crate::types::error::builders::InvalidGreetingBuilder::default()
-108
+    }
-109
+}
-110

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/Cargo.toml

@@ -1,1 +47,45 @@

↥ Expand context

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

 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#awsJson1_1"
 [dependencies.aws-smithy-async]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
 [dependencies.aws-smithy-compression]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-compression"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
 features = ["client"]
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-1x"]
 [dependencies.aws-smithy-schema]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-schema"

↧ Expand context

 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x", "http-body-0-4-x"]
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.fastrand]
 version = "2.0.0"
 [dependencies.flate2]
 version = "1.0.30"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.http-body-1x]
 version = "1"
 package = "http-body"
 [dependencies.http-body-util]
 version = "0.1.3"
 [dependencies.tracing]

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/config.rs

@@ -10,10 +69,73 @@

↥ Expand context

     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-15
+}
 impl Config {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     pub fn builder() -> Builder {
         Builder::default()
-26
+    }
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {

             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-34
+        }
-35
+    }
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-39
+    }
     /// Returns the client protocol used for serialization and deserialization.
     pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
         self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
-+
+    }
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-47
+    }
     /// Return the auth schemes configured on this service config
     pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
         self.runtime_components.auth_schemes()
-51
+    }
-52
     /// Return the auth scheme resolver configured on this service config

↧ Expand context

     pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
         self.runtime_components.auth_scheme_option_resolver()
-56
+    }
     /// Returns the configured auth scheme preference
     pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
         self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
-60
+    }
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-64
+    }
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-68
+    }
-69
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-73
+    }

@@ -105,109 +185,208 @@

↥ Expand context

     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-111
+}
 impl ::std::default::Default for Builder {
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-119
+        }
-120
+    }
-121
+}
 impl Builder {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>

     ///
     pub fn new() -> Self {
         Self::default()
-132
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     #[allow(unused)]
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         let mut builder = Self::new();
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
             builder.set_protocol(::std::option::Option::Some(protocol));
-+
+        }
         builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         builder
-147
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-153
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-162
+    }
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
             protocol,
         )));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         self.config.store_or_unset(protocol);
         self
-+
+    }
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use json_rpc11::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -1114,1137 +1173,1201 @@

↥ Expand context

         self.apply_test_defaults_v2();
         self
-1139
+    }
     /// Builds a [`Config`].
     #[allow(unused_mut)]
     pub fn build(mut self) -> Config {
         let mut layer = self.config;
         if self.runtime_components.time_source().is_none() {
             self.runtime_components
                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1147
+        }
         Config {
             config: crate::config::Layer::from(layer.clone()).with_name("json_rpc11::config::Config").freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
-1154
+        }
-1155
+    }
-1156
+}

 #[derive(::std::fmt::Debug)]
 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1161
+}
-1162
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("JsonProtocol");
             if _service_config.protocol().is_none() {
                 cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_1("JsonProtocol"),
                 ));
-+
+            }
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
             use crate::config::auth::ResolveAuthScheme;
             crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());

↧ Expand context

         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-1184
+    }
-1185
+}
-1186
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-1190
+    }
-1191
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
-1194
+    }
-1195
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1201
+    }

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/lib.rs

@@ -99,99 +133,131 @@

↥ Expand context

 /// function on the fluent builder. See the [`customize`](crate::client::customize) module for more
 /// information.
 pub mod client;
-102
 /// Configuration for Sample Json 1.1 Protocol Service.
 pub mod config;
-105
 /// Common errors and error handling utilities.
 pub mod error;
-108
 mod error_meta;
-110
 /// Information about this crate.
 pub mod meta;
-113
 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-116
 /// Data structures used by operation inputs/outputs.
 pub mod types;

-119
 mod client_request_compression;
-121
 /// All operations that this crate can perform.
 pub mod operation;
-124
 pub(crate) mod protocol_serde;
-126
 mod sdk_feature_tracker;
-128
 mod serialization_settings;
--
 mod json_errors;
-130
 pub use client::Client;

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/content_type_parameters.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ContentTypeParameters`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ContentTypeParameters;
 impl ContentTypeParameters {
     /// Creates a new `ContentTypeParameters`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::content_type_parameters::ContentTypeParametersInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::content_type_parameters::ContentTypeParametersOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::content_type_parameters::ContentTypeParametersInput,
     ) -> ::std::result::Result<
         crate::operation::content_type_parameters::ContentTypeParametersOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::content_type_parameters::ContentTypeParametersError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::content_type_parameters::ContentTypeParametersError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::content_type_parameters::ContentTypeParametersOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -113,117 +239,239 @@

↥ Expand context

         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ContentTypeParameters")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ContentTypeParametersEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::content_type_parameters::ContentTypeParametersError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::content_type_parameters::ContentTypeParametersError,
             >::new());
-136

         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct ContentTypeParametersResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ContentTypeParametersResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::content_type_parameters::ContentTypeParametersError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ContentTypeParameters::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::content_type_parameters::ContentTypeParametersOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-188
+    }
-189
+}
 #[derive(Debug)]
 struct ContentTypeParametersRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ContentTypeParametersRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::content_type_parameters::ContentTypeParametersInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::content_type_parameters::ContentTypeParametersInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::content_type_parameters::ContentTypeParametersInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonProtocol.ContentTypeParameters",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, ContentTypeParameters::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-210
+    }
-211
+}
 #[derive(Debug)]
 struct ContentTypeParametersEndpointParamsInterceptor;
-214
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ContentTypeParametersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ContentTypeParametersEndpointParamsInterceptor"
-218
+    }
-219

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ContentTypeParametersInput>()
             .ok_or("failed to downcast to ContentTypeParametersInput")?;
-234
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/content_type_parameters/_content_type_parameters_input.rs

@@ -23,23 +108,119 @@

↥ Expand context

         "aws.protocoltests.json.synthetic",
         "ContentTypeParametersInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "value",
 ,
 );
 static CONTENTTYPEPARAMETERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONTENTTYPEPARAMETERSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CONTENTTYPEPARAMETERSINPUT_MEMBER_VALUE],
 );
 impl ContentTypeParametersInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONTENTTYPEPARAMETERSINPUT_SCHEMA;
-38
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ContentTypeParametersInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,

         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.value {
             ser.write_integer(&CONTENTTYPEPARAMETERSINPUT_MEMBER_VALUE, *val)?;
-47
+        }
         Ok(())
-49
+    }
-50
+}
 impl ContentTypeParametersInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CONTENTTYPEPARAMETERSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONTENTTYPEPARAMETERSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.value = Some(deser.read_integer(member)?);
-69
+                }
                 _ => {}
-71
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-77
+    }
-78
+}
 impl ContentTypeParametersInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ContentTypeParametersInput {
     /// Creates a new builder-style object to manufacture [`ContentTypeParametersInput`](crate::operation::content_type_parameters::ContentTypeParametersInput).
     pub fn builder() -> crate::operation::content_type_parameters::builders::ContentTypeParametersInputBuilder {
         crate::operation::content_type_parameters::builders::ContentTypeParametersInputBuilder::default()
-94
+    }
-95
+}
-96
 /// A builder for [`ContentTypeParametersInput`](crate::operation::content_type_parameters::ContentTypeParametersInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ContentTypeParametersInputBuilder {
     pub(crate) value: ::std::option::Option<i32>,
-102
+}
 impl ContentTypeParametersInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn value(mut self, input: i32) -> Self {
         self.value = ::std::option::Option::Some(input);
         self
-108
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_value(mut self, input: ::std::option::Option<i32>) -> Self {
         self.value = input;
         self
-113
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_value(&self) -> &::std::option::Option<i32> {
         &self.value
-117
+    }
     /// Consumes the builder and constructs a [`ContentTypeParametersInput`](crate::operation::content_type_parameters::ContentTypeParametersInput).
     pub fn build(

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/content_type_parameters/_content_type_parameters_output.rs

@@ -1,1 +65,76 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ContentTypeParametersOutput {}
 static CONTENTTYPEPARAMETERSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "aws.protocoltests.json.synthetic#ContentTypeParametersOutput",
     "aws.protocoltests.json.synthetic",
     "ContentTypeParametersOutput",
 );
 static CONTENTTYPEPARAMETERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(CONTENTTYPEPARAMETERSOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 impl ContentTypeParametersOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONTENTTYPEPARAMETERSOUTPUT_SCHEMA;
-16
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ContentTypeParametersOutput {

     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-24
+    }
-25
+}
 impl ContentTypeParametersOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CONTENTTYPEPARAMETERSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONTENTTYPEPARAMETERSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 _ => {}
-43
+            }
             Ok(())
         })?;
         Ok(builder.build())
-47
+    }
-48
+}
 impl ContentTypeParametersOutput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Ok(Self::builder().build())
-+
+    }
-+
+}
 impl ContentTypeParametersOutput {
     /// Creates a new builder-style object to manufacture [`ContentTypeParametersOutput`](crate::operation::content_type_parameters::ContentTypeParametersOutput).
     pub fn builder() -> crate::operation::content_type_parameters::builders::ContentTypeParametersOutputBuilder {
         crate::operation::content_type_parameters::builders::ContentTypeParametersOutputBuilder::default()
-64
+    }
-65
+}
-66
 /// A builder for [`ContentTypeParametersOutput`](crate::operation::content_type_parameters::ContentTypeParametersOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ContentTypeParametersOutputBuilder {}
 impl ContentTypeParametersOutputBuilder {
     /// Consumes the builder and constructs a [`ContentTypeParametersOutput`](crate::operation::content_type_parameters::ContentTypeParametersOutput).
     pub fn build(self) -> crate::operation::content_type_parameters::ContentTypeParametersOutput {
         crate::operation::content_type_parameters::ContentTypeParametersOutput {}
-75
+    }
-76
+}

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/operation/datetime_offsets.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `DatetimeOffsets`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DatetimeOffsets;
 impl DatetimeOffsets {
     /// Creates a new `DatetimeOffsets`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::datetime_offsets::DatetimeOffsetsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::datetime_offsets::DatetimeOffsetsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::datetime_offsets::DatetimeOffsetsInput,
     ) -> ::std::result::Result<
         crate::operation::datetime_offsets::DatetimeOffsetsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::datetime_offsets::DatetimeOffsetsError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::datetime_offsets::DatetimeOffsetsError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::datetime_offsets::DatetimeOffsetsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -107,111 +228,233 @@

↥ Expand context

         ));
-112
         ::std::option::Option::Some(cfg.freeze())
-114
+    }
-115
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DatetimeOffsets")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(DatetimeOffsetsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::datetime_offsets::DatetimeOffsetsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::datetime_offsets::DatetimeOffsetsError,
             >::new());
-130

         ::std::borrow::Cow::Owned(rcb)
-132
+    }
-133
+}
-134
 #[derive(Debug)]
 struct DatetimeOffsetsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DatetimeOffsetsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-146
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
-+
             let generic = generic_builder.build();
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(
                     crate::operation::datetime_offsets::DatetimeOffsetsError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, DatetimeOffsets::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-182
+    }
-183
+}
 #[derive(Debug)]
 struct DatetimeOffsetsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DatetimeOffsetsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::datetime_offsets::DatetimeOffsetsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::datetime_offsets::DatetimeOffsetsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::datetime_offsets::DatetimeOffsetsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonProtocol.DatetimeOffsets",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_input(&input)?);
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, DatetimeOffsets::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-202
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-204
+    }
-205
+}
 #[derive(Debug)]
 struct DatetimeOffsetsEndpointParamsInterceptor;
-208
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DatetimeOffsetsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DatetimeOffsetsEndpointParamsInterceptor"
-212
+    }
-213

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<DatetimeOffsetsInput>()
             .ok_or("failed to downcast to DatetimeOffsetsInput")?;
-228
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

@@ -247,252 +353,378 @@

↥ Expand context

                 1576540098, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.1")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "      {\n          \"datetime\": \"2019-12-16T22:48:18-01:00\"\n      }\n",
                 ))
                 .unwrap(),
-263
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-267
         let op = crate::operation::datetime_offsets::DatetimeOffsets::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()

             .expect("the config must have a deserializer");
-273
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_1("JsonProtocol"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::datetime_offsets::DatetimeOffsetsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.datetime, expected_output.datetime, "Unexpected value for `datetime`");
-299
+    }
-300
     /// Ensures that clients can correctly parse datetime (timestamps) with offsets
     /// Test ID: AwsJson11DateTimeWithPositiveOffset
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn aws_json11_date_time_with_positive_offset_response() {
         let expected_output = crate::operation::datetime_offsets::DatetimeOffsetsOutput::builder()
             .set_datetime(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1576540098, 0_f64,
             )))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http_1x::response::Builder::new()
                 .header("Content-Type", "application/x-amz-json-1.1")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from(
                     "      {\n          \"datetime\": \"2019-12-17T00:48:18+01:00\"\n      }\n",
                 ))
                 .unwrap(),
-319
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-323
         let op = crate::operation::datetime_offsets::DatetimeOffsets::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-329
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response = http_response.map(|body| {
                 ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     body.bytes().unwrap(),
                     ::aws_smithy_protocol_test::MediaType::from("application/json"),
                 )))
             });
             de.deserialize_nonstreaming(&http_response)
             // Build a config bag with the protocol for schema-based deserialization
             #[allow(unused_mut)]
             let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
-+
+            {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("test_protocol");
                 layer.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_1("JsonProtocol"),
                 ));
                 test_cfg.push_shared_layer(layer.freeze());
-+
+            }
             de.deserialize_nonstreaming(&http_response, &test_cfg)
         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::datetime_offsets::DatetimeOffsetsOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.datetime, expected_output.datetime, "Unexpected value for `datetime`");
-355
+    }
-356
+}
-357
 /// Error type for the `DatetimeOffsetsError` operation.

↧ Expand context

 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum DatetimeOffsetsError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-365
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-367
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-DatetimeOffsetsError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-370
+}
 impl DatetimeOffsetsError {
     /// Creates the `DatetimeOffsetsError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),

Client Test

Files changed: