Client Test

rev. bbca34fa2eddb4be623fbbc6b6df1a2401de0029

Files changed:

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_defaults/_operation_with_defaults_output.rs

@@ -150,150 +209,824 @@

-150
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn empty_blob(&self) -> &::aws_smithy_types::Blob {
         &self.empty_blob
-154
+    }
     #[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 OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_STRING: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultString",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "defaultString",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BOOLEAN: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultBoolean",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "defaultBoolean",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10#TestStringList$member",
         "aws.protocoltests.json10",
         "TestStringList",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "member",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultList",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "defaultList",
 ,
-+
+)
 .with_list_member(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST_MEMBER);
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_MAP: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultDocumentMap",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "defaultDocumentMap",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_STRING: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultDocumentString",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "defaultDocumentString",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_BOOLEAN: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultDocumentBoolean",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "defaultDocumentBoolean",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_LIST: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultDocumentList",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "defaultDocumentList",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_NULL_DOCUMENT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultNullDocument",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "defaultNullDocument",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_TIMESTAMP: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultTimestamp",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "defaultTimestamp",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BLOB: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultBlob",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "defaultBlob",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BYTE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultByte",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "defaultByte",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_SHORT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultShort",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "defaultShort",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INTEGER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultInteger",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "defaultInteger",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LONG: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultLong",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "defaultLong",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_FLOAT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultFloat",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "defaultFloat",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOUBLE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultDouble",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "defaultDouble",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("aws.protocoltests.json10#TestStringMap$key", "aws.protocoltests.json10", "TestStringMap"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10#TestStringMap$value",
         "aws.protocoltests.json10",
         "TestStringMap",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "value",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultMap",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "defaultMap",
 ,
-+
+)
 .with_map_members(
     &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP_KEY,
     &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP_VALUE,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_ENUM: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultEnum",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "defaultEnum",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INT_ENUM: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$defaultIntEnum",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "defaultIntEnum",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_STRING: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$emptyString",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "emptyString",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_FALSE_BOOLEAN: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$falseBoolean",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "falseBoolean",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_BLOB: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$emptyBlob",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "emptyBlob",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_BYTE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$zeroByte",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Byte,
     "zeroByte",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_SHORT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$zeroShort",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Short,
     "zeroShort",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_INTEGER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$zeroInteger",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "zeroInteger",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_LONG: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$zeroLong",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "zeroLong",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_FLOAT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$zeroFloat",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Float,
     "zeroFloat",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_DOUBLE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput$zeroDouble",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "zeroDouble",
 ,
 );
 static OPERATIONWITHDEFAULTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithDefaultsOutput",
         "aws.protocoltests.json10.synthetic",
         "OperationWithDefaultsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_STRING,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BOOLEAN,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_MAP,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_STRING,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_BOOLEAN,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_LIST,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_NULL_DOCUMENT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_TIMESTAMP,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BLOB,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BYTE,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_SHORT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INTEGER,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LONG,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_FLOAT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOUBLE,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_MAP,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_ENUM,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INT_ENUM,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_STRING,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_FALSE_BOOLEAN,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_BLOB,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_BYTE,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_SHORT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_INTEGER,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_LONG,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_FLOAT,
         &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_DOUBLE,
     ],
-+
+)
 .with_original_name("OperationWithDefaultsOutput");
 impl OperationWithDefaultsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPERATIONWITHDEFAULTSOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithDefaultsOutput {
     #[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> {
-+
+        {
             let val = &self.default_string;
             ser.write_string(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_STRING, val)?;
-+
+        }
-+
+        {
             let val = &self.default_boolean;
             ser.write_boolean(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BOOLEAN, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_list;
-+
             ser.write_list(
                 &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
-+
+        {
             let val = &self.default_document_map;
             ser.write_document(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_MAP, val)?;
-+
+        }
-+
+        {
             let val = &self.default_document_string;
             ser.write_document(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_STRING, val)?;
-+
+        }
-+
+        {
             let val = &self.default_document_boolean;
             ser.write_document(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_BOOLEAN, val)?;
-+
+        }
-+
+        {
             let val = &self.default_document_list;
             ser.write_document(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOCUMENT_LIST, val)?;
-+
+        }
         if let Some(ref val) = self.default_null_document {
             ser.write_document(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_NULL_DOCUMENT, val)?;
-+
+        }
-+
+        {
             let val = &self.default_timestamp;
             ser.write_timestamp(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_TIMESTAMP, val)?;
-+
+        }
-+
+        {
             let val = &self.default_blob;
             ser.write_blob(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BLOB, val.clone())?;
-+
+        }
-+
+        {
             let val = &self.default_byte;
             ser.write_byte(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_BYTE, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_short;
             ser.write_short(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_SHORT, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_integer;
             ser.write_integer(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INTEGER, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_long;
             ser.write_long(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_LONG, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_float;
             ser.write_float(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_FLOAT, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_double;
             ser.write_double(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_DOUBLE, *val)?;
-+
+        }
-+
+        {
             let val = &self.default_map;
-+
             ser.write_map(
                 &OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_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_string(&::aws_smithy_schema::prelude::STRING, value)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
-+
+        {
             let val = &self.default_enum;
             ser.write_string(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_ENUM, val.as_str())?;
-+
+        }
-+
+        {
             let val = &self.default_int_enum;
             ser.write_integer(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_DEFAULT_INT_ENUM, *val)?;
-+
+        }
-+
+        {
             let val = &self.empty_string;
             ser.write_string(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_STRING, val)?;
-+
+        }
-+
+        {
             let val = &self.false_boolean;
             ser.write_boolean(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_FALSE_BOOLEAN, *val)?;
-+
+        }
-+
+        {
             let val = &self.empty_blob;
             ser.write_blob(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_EMPTY_BLOB, val.clone())?;
-+
+        }
-+
+        {
             let val = &self.zero_byte;
             ser.write_byte(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_BYTE, *val)?;
-+
+        }
-+
+        {
             let val = &self.zero_short;
             ser.write_short(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_SHORT, *val)?;
-+
+        }
-+
+        {
             let val = &self.zero_integer;
             ser.write_integer(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_INTEGER, *val)?;
-+
+        }
-+
+        {
             let val = &self.zero_long;
             ser.write_long(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_LONG, *val)?;
-+
+        }
-+
+        {
             let val = &self.zero_float;
             ser.write_float(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_FLOAT, *val)?;
-+
+        }
-+
+        {
             let val = &self.zero_double;
             ser.write_double(&OPERATIONWITHDEFAULTSOUTPUT_MEMBER_ZERO_DOUBLE, *val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl OperationWithDefaultsOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&OPERATIONWITHDEFAULTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.default_string = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.default_boolean = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(2) => {
                     builder.default_list = Some(deser.read_string_list(member)?);
-+
+                }
                 Some(3) => {
                     builder.default_document_map = Some(deser.read_document(member)?);
-+
+                }
                 Some(4) => {
                     builder.default_document_string = Some(deser.read_document(member)?);
-+
+                }
                 Some(5) => {
                     builder.default_document_boolean = Some(deser.read_document(member)?);
-+
+                }
                 Some(6) => {
                     builder.default_document_list = Some(deser.read_document(member)?);
-+
+                }
                 Some(7) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.default_null_document = Some(deser.read_document(member)?);
-+
+                    }
-+
+                }
                 Some(8) => {
                     builder.default_timestamp = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(9) => {
                     builder.default_blob = Some(deser.read_blob(member)?);
-+
+                }
                 Some(10) => {
                     builder.default_byte = Some(deser.read_byte(member)?);
-+
+                }
                 Some(11) => {
                     builder.default_short = Some(deser.read_short(member)?);
-+
+                }
                 Some(12) => {
                     builder.default_integer = Some(deser.read_integer(member)?);
-+
+                }
                 Some(13) => {
                     builder.default_long = Some(deser.read_long(member)?);
-+
+                }
                 Some(14) => {
                     builder.default_float = Some(deser.read_float(member)?);
-+
+                }
                 Some(15) => {
                     builder.default_double = Some(deser.read_double(member)?);
-+
+                }
                 Some(16) => {
                     builder.default_map = Some(deser.read_string_string_map(member)?);
-+
+                }
                 Some(17) => {
                     builder.default_enum = Some(crate::types::TestEnum::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(18) => {
                     builder.default_int_enum = Some(deser.read_integer(member)?);
-+
+                }
                 Some(19) => {
                     builder.empty_string = Some(deser.read_string(member)?);
-+
+                }
                 Some(20) => {
                     builder.false_boolean = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(21) => {
                     builder.empty_blob = Some(deser.read_blob(member)?);
-+
+                }
                 Some(22) => {
                     builder.zero_byte = Some(deser.read_byte(member)?);
-+
+                }
                 Some(23) => {
                     builder.zero_short = Some(deser.read_short(member)?);
-+
+                }
                 Some(24) => {
                     builder.zero_integer = Some(deser.read_integer(member)?);
-+
+                }
                 Some(25) => {
                     builder.zero_long = Some(deser.read_long(member)?);
-+
+                }
                 Some(26) => {
                     builder.zero_float = Some(deser.read_float(member)?);
-+
+                }
                 Some(27) => {
                     builder.zero_double = Some(deser.read_double(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl OperationWithDefaultsOutput {
     /// 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 OperationWithDefaultsOutput {
     /// Creates a new builder-style object to manufacture [`OperationWithDefaultsOutput`](crate::operation::operation_with_defaults::OperationWithDefaultsOutput).
     pub fn builder() -> crate::operation::operation_with_defaults::builders::OperationWithDefaultsOutputBuilder {
         crate::operation::operation_with_defaults::builders::OperationWithDefaultsOutputBuilder::default()
-799
+    }
-800
+}
-801
 /// A builder for [`OperationWithDefaultsOutput`](crate::operation::operation_with_defaults::OperationWithDefaultsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithDefaultsOutputBuilder {
     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/operation/operation_with_nested_structure.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `OperationWithNestedStructure`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct OperationWithNestedStructure;
 impl OperationWithNestedStructure {
     /// Creates a new `OperationWithNestedStructure`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
         crate::operation::operation_with_nested_structure::OperationWithNestedStructureInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
         crate::operation::operation_with_nested_structure::OperationWithNestedStructureOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::operation_with_nested_structure::OperationWithNestedStructureInput,
     ) -> ::std::result::Result<
         crate::operation::operation_with_nested_structure::OperationWithNestedStructureOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::operation_with_nested_structure::OperationWithNestedStructureError,
             ::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::operation_with_nested_structure::OperationWithNestedStructureError>()
                     .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::operation_with_nested_structure::OperationWithNestedStructureOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -120,126 +244,258 @@

↥ Expand context

         _: &::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("OperationWithNestedStructure")
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
             ))
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 OperationWithNestedStructureEndpointParamsInterceptor,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::operation_with_nested_structure::OperationWithNestedStructureError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::operation_with_nested_structure::OperationWithNestedStructureError,
             >::new());
-142
         ::std::borrow::Cow::Owned(rcb)
-144
+    }
-145
+}

-146
 #[derive(Debug)]
 struct OperationWithNestedStructureResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationWithNestedStructureResponseDeserializer {
     fn deserialize_nonstreaming_with_config(
         &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();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-164
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).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::operation_with_nested_structure::OperationWithNestedStructureError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_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, OperationWithNestedStructure::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::operation_with_nested_structure::OperationWithNestedStructureOutput::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))
-+
+        }
-206
+    }
-207
+}
 #[derive(Debug)]
 struct OperationWithNestedStructureRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OperationWithNestedStructureRequestSerializer {
     #[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::operation_with_nested_structure::OperationWithNestedStructureInput>()
             .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::operation_with_nested_structure::OperationWithNestedStructureInput,
                 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::operation_with_nested_structure::OperationWithNestedStructureInput,
                 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.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.OperationWithNestedStructure",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_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, OperationWithNestedStructure::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-229
+    }
-230
+}
 #[derive(Debug)]
 struct OperationWithNestedStructureEndpointParamsInterceptor;
-233
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationWithNestedStructureEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationWithNestedStructureEndpointParamsInterceptor"
-238
+    }

↧ Expand context

-239
     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::<OperationWithNestedStructureInput>()
             .ok_or("failed to downcast to OperationWithNestedStructureInput")?;
-254
         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()

@@ -393,407 +452,473 @@

↥ Expand context

                         .set_greeting(::std::option::Option::Some("konnichiwa".to_owned()))
                         .set_farewell(::std::option::Option::Some(
                             crate::types::Farewell::builder()
                                 .set_phrase(::std::option::Option::Some("sayonara".to_owned()))
                                 .build(),
                         ))
                         .build(),
                 );
                 ret
             }))
             .build()
             .unwrap();
         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.0")
         .status(200)
                     .body(::aws_smithy_types::body::SdkBody::from("{\n    \"dialog\": {\n        \"language\": \"en\"\n    },\n    \"dialogList\": [\n        {\n        },\n        {\n            \"farewell\": {}\n        },\n        {\n            \"language\": \"it\",\n            \"greeting\": \"ciao\",\n            \"farewell\": {\n                \"phrase\": \"arrivederci\"\n            }\n        }\n    ],\n    \"dialogMap\": {\n        \"emptyDialog\": {\n        },\n        \"partialEmptyDialog\": {\n            \"language\": \"en\",\n            \"farewell\": {}\n        },\n        \"nonEmptyDialog\": {\n            \"greeting\": \"konnichiwa\",\n            \"farewell\": {\n                \"phrase\": \"sayonara\"\n            }\n        }\n    }\n}"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-427
         let op = crate::operation::operation_with_nested_structure::OperationWithNestedStructure::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");
-433
         // 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_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-444
         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_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::operation_with_nested_structure::OperationWithNestedStructureOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(parsed.dialog, expected_output.dialog, "Unexpected value for `dialog`");
         ::pretty_assertions::assert_eq!(parsed.dialog_list, expected_output.dialog_list, "Unexpected value for `dialog_list`");
         ::pretty_assertions::assert_eq!(parsed.dialog_map, expected_output.dialog_map, "Unexpected value for `dialog_map`");
-462
+    }
-463
+}
-464
 /// Error type for the `OperationWithNestedStructureError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum OperationWithNestedStructureError {
     /// 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()`:
-472
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_nested_structure/_operation_with_nested_structure_input.rs

@@ -1,1 +44,122 @@

↥ 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 OperationWithNestedStructureInput {
     #[allow(missing_docs)] // documentation missing in model
     pub top_level: ::std::option::Option<crate::types::TopLevel>,
-8
+}
 impl OperationWithNestedStructureInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn top_level(&self) -> ::std::option::Option<&crate::types::TopLevel> {
         self.top_level.as_ref()
-13
+    }
-14
+}
 static OPERATIONWITHNESTEDSTRUCTUREINPUT_MEMBER_TOP_LEVEL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithNestedStructureInput$topLevel",
         "aws.protocoltests.json10.synthetic",
         "OperationWithNestedStructureInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "topLevel",
 ,
 );
 static OPERATIONWITHNESTEDSTRUCTUREINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithNestedStructureInput",
         "aws.protocoltests.json10.synthetic",
         "OperationWithNestedStructureInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&OPERATIONWITHNESTEDSTRUCTUREINPUT_MEMBER_TOP_LEVEL],
-+
+)
 .with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
 .with_original_name("OperationWithNestedStructureInput");
 impl OperationWithNestedStructureInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPERATIONWITHNESTEDSTRUCTUREINPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithNestedStructureInput {
     #[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_struct(&OPERATIONWITHNESTEDSTRUCTUREINPUT_MEMBER_TOP_LEVEL, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl OperationWithNestedStructureInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&OPERATIONWITHNESTEDSTRUCTUREINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.top_level = Some(crate::types::TopLevel::deserialize(deser)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl OperationWithNestedStructureInput {
     /// 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 OperationWithNestedStructureInput {
     /// Creates a new builder-style object to manufacture [`OperationWithNestedStructureInput`](crate::operation::operation_with_nested_structure::OperationWithNestedStructureInput).
     pub fn builder() -> crate::operation::operation_with_nested_structure::builders::OperationWithNestedStructureInputBuilder {
         crate::operation::operation_with_nested_structure::builders::OperationWithNestedStructureInputBuilder::default()
-97
+    }
-98
+}
-99
 /// A builder for [`OperationWithNestedStructureInput`](crate::operation::operation_with_nested_structure::OperationWithNestedStructureInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithNestedStructureInputBuilder {
     pub(crate) top_level: ::std::option::Option<crate::types::TopLevel>,
-105
+}
 impl OperationWithNestedStructureInputBuilder {
     #[allow(missing_docs)] // documentation missing in model
     /// This field is required.
     pub fn top_level(mut self, input: crate::types::TopLevel) -> Self {
         self.top_level = ::std::option::Option::Some(input);
         self
-112
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_top_level(mut self, input: ::std::option::Option<crate::types::TopLevel>) -> Self {
         self.top_level = input;
         self
-117
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_top_level(&self) -> &::std::option::Option<crate::types::TopLevel> {
         &self.top_level
-121
+    }
     /// Consumes the builder and constructs a [`OperationWithNestedStructureInput`](crate::operation::operation_with_nested_structure::OperationWithNestedStructureInput).

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/operation/operation_with_nested_structure/_operation_with_nested_structure_output.rs

@@ -1,1 +57,225 @@

↥ 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 OperationWithNestedStructureOutput {
     #[allow(missing_docs)] // documentation missing in model
     pub dialog: crate::types::Dialog,
     #[allow(missing_docs)] // documentation missing in model
     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 OperationWithNestedStructureOutput {
     #[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 OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithNestedStructureOutput$dialog",
         "aws.protocoltests.json10.synthetic",
         "OperationWithNestedStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "dialog",
 ,
 );
 static OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_LIST_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("aws.protocoltests.json10#DialogList$member", "aws.protocoltests.json10", "DialogList"),
     ::aws_smithy_schema::ShapeType::Structure,
     "member",
 ,
 );
 static OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_LIST: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithNestedStructureOutput$dialogList",
         "aws.protocoltests.json10.synthetic",
         "OperationWithNestedStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "dialogList",
 ,
-+
+)
 .with_list_member(&OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_LIST_MEMBER);
 static OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_MAP_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("aws.protocoltests.json10#DialogMap$key", "aws.protocoltests.json10", "DialogMap"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
 ,
 );
 static OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_MAP_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("aws.protocoltests.json10#DialogMap$value", "aws.protocoltests.json10", "DialogMap"),
     ::aws_smithy_schema::ShapeType::Structure,
     "value",
 ,
 );
 static OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_MAP: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithNestedStructureOutput$dialogMap",
         "aws.protocoltests.json10.synthetic",
         "OperationWithNestedStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "dialogMap",
 ,
-+
+)
 .with_map_members(
     &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_MAP_KEY,
     &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_MAP_VALUE,
 );
 static OPERATIONWITHNESTEDSTRUCTUREOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts(
         "aws.protocoltests.json10.synthetic#OperationWithNestedStructureOutput",
         "aws.protocoltests.json10.synthetic",
         "OperationWithNestedStructureOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG,
         &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_LIST,
         &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_MAP,
     ],
-+
+)
 .with_original_name("OperationWithNestedStructureOutput");
 impl OperationWithNestedStructureOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for OperationWithNestedStructureOutput {
     #[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> {
-+
+        {
             let val = &self.dialog;
             ser.write_struct(&OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG, val)?;
-+
+        }
-+
+        {
             let val = &self.dialog_list;
-+
             ser.write_list(
                 &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_MEMBER_DIALOG_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Dialog::SCHEMA, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
-+
+        {
             let val = &self.dialog_map;
-+
             ser.write_map(
                 &OPERATIONWITHNESTEDSTRUCTUREOUTPUT_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)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl OperationWithNestedStructureOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     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(&OPERATIONWITHNESTEDSTRUCTUREOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.dialog = Some(crate::types::Dialog::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder.dialog_list = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Dialog::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(2) => {
                     builder.dialog_map = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::Dialog::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl OperationWithNestedStructureOutput {
     /// 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 OperationWithNestedStructureOutput {
     /// Creates a new builder-style object to manufacture [`OperationWithNestedStructureOutput`](crate::operation::operation_with_nested_structure::OperationWithNestedStructureOutput).
     pub fn builder() -> crate::operation::operation_with_nested_structure::builders::OperationWithNestedStructureOutputBuilder {
         crate::operation::operation_with_nested_structure::builders::OperationWithNestedStructureOutputBuilder::default()
-200
+    }
-201
+}
-202
 /// A builder for [`OperationWithNestedStructureOutput`](crate::operation::operation_with_nested_structure::OperationWithNestedStructureOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct OperationWithNestedStructureOutputBuilder {
     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>>,
-210
+}
 impl OperationWithNestedStructureOutputBuilder {
     #[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
-217
+    }
     #[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
-222
+    }
     #[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/operation/operation_with_required_members.rs

@@ -1,1 +40,46 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `OperationWithRequiredMembers`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct OperationWithRequiredMembers;
 impl OperationWithRequiredMembers {
     /// Creates a new `OperationWithRequiredMembers`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
         crate::operation::operation_with_required_members::OperationWithRequiredMembersInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
         crate::operation::operation_with_required_members::OperationWithRequiredMembersOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::operation_with_required_members::OperationWithRequiredMembersInput,
     ) -> ::std::result::Result<
         crate::operation::operation_with_required_members::OperationWithRequiredMembersOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::operation_with_required_members::OperationWithRequiredMembersError,
             ::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::operation_with_required_members::OperationWithRequiredMembersError>()
                     .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::operation_with_required_members::OperationWithRequiredMembersOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -120,126 +241,258 @@

↥ Expand context

         _: &::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("OperationWithRequiredMembers")
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
             ))
             .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
                 OperationWithRequiredMembersEndpointParamsInterceptor,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::operation_with_required_members::OperationWithRequiredMembersError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::operation_with_required_members::OperationWithRequiredMembersError,
             >::new());
-142
         ::std::borrow::Cow::Owned(rcb)
-144
+    }
-145
+}

-146
 #[derive(Debug)]
 struct OperationWithRequiredMembersResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for OperationWithRequiredMembersResponseDeserializer {
     fn deserialize_nonstreaming_with_config(
         &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();
         // Load body and headers BEFORE BeforeParseResponse so customizations
         // (e.g., S3's `body_is_error` check that detects errors returned with
         // HTTP 200) can inspect them. The legacy non-streaming path also
         // loads `body` before firing this hook.
         let body = response.body().bytes().expect("body loaded");
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut force_error = false;
-164
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_operation_with_required_members::de_operation_with_required_members_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             #[allow(unused_mut)]
             let mut generic_builder = protocol.parse_error_metadata(response, _cfg).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::operation_with_required_members::OperationWithRequiredMembersError::generic(generic),
                 ),
             ))
         } else {
             crate::protocol_serde::shape_operation_with_required_members::de_operation_with_required_members_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, OperationWithRequiredMembers::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             // body and headers are already in scope from the top of the function;
             // alias `headers` as `_response_headers` so MutateOutput
             // customizations have a stable name to read from.
             let _response_headers = headers;
             #[allow(unused_mut)]
             let mut output = crate::operation::operation_with_required_members::OperationWithRequiredMembersOutput::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))
-+
+        }
-206
+    }
-207
+}
 #[derive(Debug)]
 struct OperationWithRequiredMembersRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for OperationWithRequiredMembersRequestSerializer {
     #[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::operation_with_required_members::OperationWithRequiredMembersInput>()
             .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::operation_with_required_members::OperationWithRequiredMembersInput,
                 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::operation_with_required_members::OperationWithRequiredMembersInput,
                 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.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "JsonRpc10.OperationWithRequiredMembers",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_operation_with_required_members::ser_operation_with_required_members_input(&input)?,
         );
-220
         ::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, OperationWithRequiredMembers::INPUT_SCHEMA, "/", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-229
+    }
-230
+}
 #[derive(Debug)]
 struct OperationWithRequiredMembersEndpointParamsInterceptor;
-233
 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for OperationWithRequiredMembersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "OperationWithRequiredMembersEndpointParamsInterceptor"
-238
+    }

↧ Expand context

-239
     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::<OperationWithRequiredMembersInput>()
             .ok_or("failed to downcast to OperationWithRequiredMembersInput")?;
-254
         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()

@@ -265,282 +324,348 @@

↥ Expand context

             .set_required_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
             .set_required_byte(::std::option::Option::Some(0))
             .set_required_short(::std::option::Option::Some(0))
             .set_required_integer(::std::option::Option::Some(0))
             .set_required_long(::std::option::Option::Some(0))
             .set_required_float(::std::option::Option::Some(0.0_f32))
             .set_required_double(::std::option::Option::Some(0.0_f64))
             .set_required_map(::std::option::Option::Some(::std::collections::HashMap::new()))
             .build()
             .unwrap();
         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.0")
                 .status(200)
                 .body(::aws_smithy_types::body::SdkBody::from("{}"))
                 .unwrap(),
-298
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;

-302
         let op = crate::operation::operation_with_required_members::OperationWithRequiredMembers::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");
-308
         // 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_0().with_target_prefix("JsonRpc10"),
             ));
             test_cfg.push_shared_layer(layer.freeze());
-+
+        }
-319
         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_with_config(&http_response, &test_cfg)

↧ Expand context

         });
         let parsed = parsed
             .expect("should be successful response")
             .downcast::<crate::operation::operation_with_required_members::OperationWithRequiredMembersOutput>()
             .unwrap();
         ::pretty_assertions::assert_eq!(
             parsed.required_string,
             expected_output.required_string,
             "Unexpected value for `required_string`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.required_boolean,
             expected_output.required_boolean,
             "Unexpected value for `required_boolean`"
         );
         ::pretty_assertions::assert_eq!(
             parsed.required_list,
             expected_output.required_list,
             "Unexpected value for `required_list`"
         );

Pages: 1 2 3 4 5 6 7 8 9 10