Client Test

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_case_insensitive_error_operation.rs

@@ -2,2 +70,64 @@

 #[allow(clippy::unnecessary_wraps)]
 pub fn de_case_insensitive_error_operation_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationOutput,
     crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::unhandled(generic)),
     };
-19
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "CaseInsensitiveError" => crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::CaseInsensitiveError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::CaseInsensitiveErrorBuilder::default();
                 output = crate::protocol_serde::shape_case_insensitive_error::de_case_insensitive_error_json_err(_response_body, output)
                     .map_err(crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ExtraError" => crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError::generic(generic),
     })
-48
+}
-49
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_case_insensitive_error_operation_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationOutput,
     crate::operation::case_insensitive_error_operation::CaseInsensitiveErrorOperationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::case_insensitive_error_operation::builders::CaseInsensitiveErrorOperationOutputBuilder::default();
         output.build()
     })
-64
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_empty_struct_with_content_on_wire_op.rs

@@ -2,2 +64,61 @@

↥ Expand context

 #[allow(clippy::unnecessary_wraps)]
 pub fn de_empty_struct_with_content_on_wire_op_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput,
     crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::unhandled(generic)),
     };
-19
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ExtraError" => crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::generic(generic),
     })
-36
+}
-37
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_empty_struct_with_content_on_wire_op_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpOutput,
     crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::empty_struct_with_content_on_wire_op::builders::EmptyStructWithContentOnWireOpOutputBuilder::default();
         output = crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op(_response_body, output)
             .map_err(crate::operation::empty_struct_with_content_on_wire_op::EmptyStructWithContentOnWireOpError::unhandled)?;
         output.build()
     })
-54
+}
-55
 pub(crate) fn de_empty_struct_with_content_on_wire_op(
     value: &[u8],
     mut builder: crate::operation::empty_struct_with_content_on_wire_op::builders::EmptyStructWithContentOnWireOpOutputBuilder,
 ) -> ::std::result::Result<
     crate::operation::empty_struct_with_content_on_wire_op::builders::EmptyStructWithContentOnWireOpOutputBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_enum_query.rs

@@ -13,13 +63,60 @@

↥ Expand context

         Some(code) => code,
         None => return Err(crate::operation::enum_query::EnumQueryError::unhandled(generic)),
     };
-16
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "ValidationException" => crate::operation::enum_query::EnumQueryError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::enum_query::EnumQueryError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::validation_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::enum_query::EnumQueryError::unhandled)?
             };
             tmp
         }),

         "ExtraError" => crate::operation::enum_query::EnumQueryError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::enum_query::EnumQueryError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::enum_query::EnumQueryError::generic(generic),
     })
-47
+}
-48
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_enum_query_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::enum_query::EnumQueryOutput, crate::operation::enum_query::EnumQueryError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::enum_query::builders::EnumQueryOutputBuilder::default();
         output.build()
     })
-60
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_escaped_string_values.rs

@@ -16,16 +78,75 @@

↥ Expand context

         Some(code) => code,
         None => return Err(crate::operation::escaped_string_values::EscapedStringValuesError::unhandled(generic)),
     };
-19
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "ValidationException" => crate::operation::escaped_string_values::EscapedStringValuesError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::escaped_string_values::EscapedStringValuesError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::validation_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::escaped_string_values::EscapedStringValuesError::unhandled)?
             };
             tmp
         }),

         "ExtraError" => crate::operation::escaped_string_values::EscapedStringValuesError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::escaped_string_values::EscapedStringValuesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::escaped_string_values::EscapedStringValuesError::generic(generic),
     })
-50
+}
-51
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_escaped_string_values_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::escaped_string_values::EscapedStringValuesOutput,
     crate::operation::escaped_string_values::EscapedStringValuesError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::escaped_string_values::builders::EscapedStringValuesOutputBuilder::default();
         output = crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values(_response_body, output)
             .map_err(crate::operation::escaped_string_values::EscapedStringValuesError::unhandled)?;
         output.build()
     })
-68
+}
-69
 pub fn ser_escaped_string_values_input(
     input: &crate::operation::escaped_string_values::EscapedStringValuesInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_escaped_string_values_input::ser_escaped_string_values_input_input(&mut object, input)?;

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_map_with_enum_key_op.rs

@@ -14,14 +76,73 @@

↥ Expand context

         Some(code) => code,
         None => return Err(crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::unhandled(generic)),
     };
-17
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "ValidationException" => crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::validation_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::unhandled)?
             };
             tmp
         }),

         "ExtraError" => crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::generic(generic),
     })
-48
+}
-49
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_map_with_enum_key_op_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::map_with_enum_key_op::MapWithEnumKeyOpOutput, crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError>
-56
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::map_with_enum_key_op::builders::MapWithEnumKeyOpOutputBuilder::default();
         output = crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op(_response_body, output)
             .map_err(crate::operation::map_with_enum_key_op::MapWithEnumKeyOpError::unhandled)?;
         output.build()
     })
-64
+}
-65
 pub fn ser_map_with_enum_key_op_input(
     input: &crate::operation::map_with_enum_key_op::MapWithEnumKeyOpInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_map_with_enum_key_op_input::ser_map_with_enum_key_op_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_null_in_non_sparse.rs

@@ -1,1 +61,58 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_null_in_non_sparse_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::null_in_non_sparse::NullInNonSparseOutput, crate::operation::null_in_non_sparse::NullInNonSparseError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::null_in_non_sparse::NullInNonSparseError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::null_in_non_sparse::NullInNonSparseError::unhandled(generic)),
     };
-16
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ExtraError" => crate::operation::null_in_non_sparse::NullInNonSparseError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::null_in_non_sparse::NullInNonSparseError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::null_in_non_sparse::NullInNonSparseError::generic(generic),
     })
-33
+}
-34
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_null_in_non_sparse_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::null_in_non_sparse::NullInNonSparseOutput, crate::operation::null_in_non_sparse::NullInNonSparseError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::null_in_non_sparse::builders::NullInNonSparseOutputBuilder::default();
         output = crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse(_response_body, output)
             .map_err(crate::operation::null_in_non_sparse::NullInNonSparseError::unhandled)?;
         output.build()
     })
-48
+}
-49
 pub(crate) fn de_null_in_non_sparse(
     value: &[u8],
     mut builder: crate::operation::null_in_non_sparse::builders::NullInNonSparseOutputBuilder,
 ) -> ::std::result::Result<
     crate::operation::null_in_non_sparse::builders::NullInNonSparseOutputBuilder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();
     let tokens = &mut tokens_owned;

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_primitive_int_header.rs

@@ -16,16 +74,71 @@

↥ Expand context

         Some(code) => code,
         None => return Err(crate::operation::primitive_int_header::PrimitiveIntHeaderError::unhandled(generic)),
     };
-19
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "ValidationException" => crate::operation::primitive_int_header::PrimitiveIntHeaderError::ValidationError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
                 output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
                     .map_err(crate::operation::primitive_int_header::PrimitiveIntHeaderError::unhandled)?;
                 let output = output.meta(generic);
                 crate::serde_util::validation_exception_correct_errors(output)
                     .build()
                     .map_err(crate::operation::primitive_int_header::PrimitiveIntHeaderError::unhandled)?
             };
             tmp
         }),

         "ExtraError" => crate::operation::primitive_int_header::PrimitiveIntHeaderError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::primitive_int_header::PrimitiveIntHeaderError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::primitive_int_header::PrimitiveIntHeaderError::generic(generic),
     })
-50
+}
-51
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_primitive_int_header_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::primitive_int_header::PrimitiveIntHeaderOutput,
     crate::operation::primitive_int_header::PrimitiveIntHeaderError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::primitive_int_header::builders::PrimitiveIntHeaderOutputBuilder::default();
         output = output.set_field(
             crate::protocol_serde::shape_primitive_int_header_output::de_field_header(_response_headers).map_err(|_| {
                 crate::operation::primitive_int_header::PrimitiveIntHeaderError::unhandled("Failed to parse field from header `x-field")
             })?,
         );
         crate::serde_util::primitive_int_header_output_output_correct_errors(output).build()
     })
-71
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_primitive_int_op.rs

@@ -1,1 +61,58 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_primitive_int_op_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::primitive_int_op::PrimitiveIntOpOutput, crate::operation::primitive_int_op::PrimitiveIntOpError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::primitive_int_op::PrimitiveIntOpError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::primitive_int_op::PrimitiveIntOpError::unhandled(generic)),
     };
-16
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ExtraError" => crate::operation::primitive_int_op::PrimitiveIntOpError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::primitive_int_op::PrimitiveIntOpError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::primitive_int_op::PrimitiveIntOpError::generic(generic),
     })
-33
+}
-34
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_primitive_int_op_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::primitive_int_op::PrimitiveIntOpOutput, crate::operation::primitive_int_op::PrimitiveIntOpError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::primitive_int_op::builders::PrimitiveIntOpOutputBuilder::default();
         output = crate::protocol_serde::shape_primitive_int_op::de_primitive_int_op(_response_body, output)
             .map_err(crate::operation::primitive_int_op::PrimitiveIntOpError::unhandled)?;
         output.build()
     })
-48
+}
-49
 pub fn ser_primitive_int_op_input(
     input: &crate::operation::primitive_int_op::PrimitiveIntOpInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_primitive_int_op_input::ser_primitive_int_op_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-58
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_query_precedence.rs

@@ -1,1 +49,46 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_query_precedence_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::query_precedence::QueryPrecedenceOutput, crate::operation::query_precedence::QueryPrecedenceError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::query_precedence::QueryPrecedenceError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::query_precedence::QueryPrecedenceError::unhandled(generic)),
     };
-16
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ExtraError" => crate::operation::query_precedence::QueryPrecedenceError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::query_precedence::QueryPrecedenceError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::query_precedence::QueryPrecedenceError::generic(generic),
     })
-33
+}
-34
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_query_precedence_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::query_precedence::QueryPrecedenceOutput, crate::operation::query_precedence::QueryPrecedenceError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::query_precedence::builders::QueryPrecedenceOutputBuilder::default();
         output.build()
     })
-46
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_status_response.rs

@@ -1,1 +50,47 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_status_response_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::status_response::StatusResponseOutput, crate::operation::status_response::StatusResponseError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::status_response::StatusResponseError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::status_response::StatusResponseError::unhandled(generic)),
     };
-16
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ExtraError" => crate::operation::status_response::StatusResponseError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::status_response::StatusResponseError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::status_response::StatusResponseError::generic(generic),
     })
-33
+}
-34
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_status_response_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::status_response::StatusResponseOutput, crate::operation::status_response::StatusResponseError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::status_response::builders::StatusResponseOutputBuilder::default();
         output = output.set_field(Some(_response_status as _));
         output.build()
     })
-47
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/protocol_serde/shape_string_payload.rs

@@ -1,1 +50,47 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_string_payload_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::string_payload::StringPayloadOutput, crate::operation::string_payload::StringPayloadError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::string_payload::StringPayloadError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::string_payload::StringPayloadError::unhandled(generic)),
     };
-16
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ExtraError" => crate::operation::string_payload::StringPayloadError::ExtraError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ExtraErrorBuilder::default();
                 output = crate::protocol_serde::shape_extra_error::de_extra_error_json_err(_response_body, output)
                     .map_err(crate::operation::string_payload::StringPayloadError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::string_payload::StringPayloadError::generic(generic),
     })
-33
+}
-34
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_string_payload_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::string_payload::StringPayloadOutput, crate::operation::string_payload::StringPayloadError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::string_payload::builders::StringPayloadOutputBuilder::default();
         output = output.set_payload(crate::protocol_serde::shape_string_payload_output::de_payload_payload(_response_body)?);
         output.build()
     })
-47
+}

tmp-codegen-diff/codegen-client-test/rest_json_extras/rust-client-codegen/src/types/_validation_exception_field.rs

@@ -1,1 +53,61 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// Describes one specific validation failure for an input member.
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub path: ::std::string::String,
     /// A detailed description of the validation failure.
     pub message: ::std::string::String,
-11
+}
 impl ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.

     pub fn path(&self) -> &str {
         use std::ops::Deref;
         self.path.deref()
-17
+    }
     /// A detailed description of the validation failure.
     pub fn message(&self) -> &str {
         use std::ops::Deref;
         self.message.deref()
-22
+    }
-23
+}
 impl ::std::fmt::Display for ValidationExceptionField {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         ::std::write!(f, "ValidationExceptionField {{")?;
         ::std::write!(f, "path={}", &self.path)?;
         ::std::write!(f, ", message={}", &self.message)?;
         ::std::write!(f, "}}")
-+
+    }
-+
+}
 impl ValidationExceptionField {
     /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::types::ValidationExceptionField).
     pub fn builder() -> crate::types::builders::ValidationExceptionFieldBuilder {
         crate::types::builders::ValidationExceptionFieldBuilder::default()
-36
+    }
-37
+}
-38
 /// A builder for [`ValidationExceptionField`](crate::types::ValidationExceptionField).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ValidationExceptionFieldBuilder {
     pub(crate) path: ::std::option::Option<::std::string::String>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
-45
+}
 impl ValidationExceptionFieldBuilder {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     /// This field is required.
     pub fn path(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.path = ::std::option::Option::Some(input.into());
         self
-52
+    }
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub fn set_path(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.path = input;
         self
-57
+    }
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub fn get_path(&self) -> &::std::option::Option<::std::string::String> {
         &self.path
-61
+    }

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_greeting_with_errors.rs

@@ -2,2 +64,61 @@

↥ Expand context

 #[allow(clippy::unnecessary_wraps)]
 pub fn de_greeting_with_errors_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::greeting_with_errors::GreetingWithErrorsOutput,
     crate::operation::greeting_with_errors::GreetingWithErrorsError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled(generic)),
     };
-19
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidGreeting" => crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidGreetingBuilder::default();
                 output = crate::protocol_serde::shape_invalid_greeting::de_invalid_greeting_xml_err(_response_body, output)
                     .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ComplexError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ComplexErrorBuilder::default();
                 output = crate::protocol_serde::shape_complex_error::de_complex_error_xml_err(_response_body, output)
                     .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
                 output = output.set_header(

↧ Expand context

                     crate::protocol_serde::shape_complex_error::de_header_header(_response_headers).map_err(|_| {
                         crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled("Failed to parse Header from header `X-Header")
                     })?,
                 );
                 let output = output.meta(generic);
                 output.build()
             };
             tmp
         }),
         _ => crate::operation::greeting_with_errors::GreetingWithErrorsError::generic(generic),
     })
-53
+}
-54
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_greeting_with_errors_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::greeting_with_errors::GreetingWithErrorsOutput,

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/types/_complex_nested_error_data.rs

@@ -1,1 +44,55 @@

↥ 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 ComplexNestedErrorData {
     #[allow(missing_docs)] // documentation missing in model
     pub foo: ::std::option::Option<::std::string::String>,
-8
+}
 impl ComplexNestedErrorData {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(&self) -> ::std::option::Option<&str> {
         self.foo.as_deref()
-13
+    }
-14
+}
 impl ::std::fmt::Display for ComplexNestedErrorData {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         ::std::write!(f, "ComplexNestedErrorData {{")?;
         if let ::std::option::Option::Some(inner) = &self.foo {
             ::std::write!(f, "foo=Some({})", inner)?;
         } else {
             ::std::write!(f, "foo=None")?;
-+
+        }
         ::std::write!(f, "}}")
-+
+    }
-+
+}
 impl ComplexNestedErrorData {
     /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
         crate::types::builders::ComplexNestedErrorDataBuilder::default()
-30
+    }
-31
+}
-32
 /// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ComplexNestedErrorDataBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
-38
+}
 impl ComplexNestedErrorDataBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-44
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-49
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-53
+    }
     /// Consumes the builder and constructs a [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn build(self) -> crate::types::ComplexNestedErrorData {

tmp-codegen-diff/codegen-client-test/rest_xml_extras_unwrapped/rust-client-codegen/src/protocol_serde/shape_greeting_with_unwrapped_errors.rs

@@ -2,2 +64,61 @@

↥ Expand context

 #[allow(clippy::unnecessary_wraps)]
 pub fn de_greeting_with_unwrapped_errors_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsOutput,
     crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::unhandled)?;
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::unhandled(generic)),
     };
-19
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidGreetingUnwrapped" => crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::InvalidGreetingUnwrapped({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidGreetingUnwrappedBuilder::default();
                 output = crate::protocol_serde::shape_invalid_greeting_unwrapped::de_invalid_greeting_unwrapped_xml_err(_response_body, output)
                     .map_err(crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ComplexErrorUnwrapped" => crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::ComplexErrorUnwrapped({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ComplexErrorUnwrappedBuilder::default();
                 output = crate::protocol_serde::shape_complex_error_unwrapped::de_complex_error_unwrapped_xml_err(_response_body, output)
                     .map_err(crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::unhandled)?;
                 output = output.set_header(

↧ Expand context

                     crate::protocol_serde::shape_complex_error_unwrapped::de_header_header(_response_headers).map_err(|_| {
                         crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::unhandled(
                             "Failed to parse Header from header `X-Header",
-45
+                        )
                     })?,
                 );
                 let output = output.meta(generic);
                 output.build()
             };
             tmp
         }),
         _ => crate::operation::greeting_with_unwrapped_errors::GreetingWithUnwrappedErrorsError::generic(generic),
     })
-55
+}
-56
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_greeting_with_unwrapped_errors_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

tmp-codegen-diff/codegen-client-test/rest_xml_extras_unwrapped/rust-client-codegen/src/types/_complex_nested_error_data.rs

@@ -1,1 +44,55 @@

↥ 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 ComplexNestedErrorData {
     #[allow(missing_docs)] // documentation missing in model
     pub foo: ::std::option::Option<::std::string::String>,
-8
+}
 impl ComplexNestedErrorData {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(&self) -> ::std::option::Option<&str> {
         self.foo.as_deref()
-13
+    }
-14
+}
 impl ::std::fmt::Display for ComplexNestedErrorData {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         ::std::write!(f, "ComplexNestedErrorData {{")?;
         if let ::std::option::Option::Some(inner) = &self.foo {
             ::std::write!(f, "foo=Some({})", inner)?;
         } else {
             ::std::write!(f, "foo=None")?;
-+
+        }
         ::std::write!(f, "}}")
-+
+    }
-+
+}
 impl ComplexNestedErrorData {
     /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
         crate::types::builders::ComplexNestedErrorDataBuilder::default()
-30
+    }
-31
+}
-32
 /// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ComplexNestedErrorDataBuilder {
     pub(crate) foo: ::std::option::Option<::std::string::String>,
-38
+}
 impl ComplexNestedErrorDataBuilder {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.foo = ::std::option::Option::Some(input.into());
         self
-44
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn set_foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.foo = input;
         self
-49
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn get_foo(&self) -> &::std::option::Option<::std::string::String> {
         &self.foo
-53
+    }
     /// Consumes the builder and constructs a [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
     pub fn build(self) -> crate::types::ComplexNestedErrorData {

Client Test

Files changed: