Client Test

Client Test

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

@@ -44,44 +130,141 @@
   64     64   
            ser.write_string(&STRUCTURELISTMEMBER_MEMBER_A, val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.b {
   67     67   
            ser.write_string(&STRUCTURELISTMEMBER_MEMBER_B, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl StructureListMember {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&STRUCTURELISTMEMBER_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&STRUCTURELISTMEMBER_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.a = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.b = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl StructureListMember {
         102  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         103  +
    pub fn deserialize_with_response(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         105  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         106  +
        _status: u16,
         107  +
        _body: &[u8],
         108  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         109  +
        Self::deserialize(deserializer)
         110  +
    }
         111  +
}
  101    112   
impl StructureListMember {
  102    113   
    /// Creates a new builder-style object to manufacture [`StructureListMember`](crate::types::StructureListMember).
  103    114   
    pub fn builder() -> crate::types::builders::StructureListMemberBuilder {
  104    115   
        crate::types::builders::StructureListMemberBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`StructureListMember`](crate::types::StructureListMember).
  109    120   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    121   
#[non_exhaustive]

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

@@ -8,8 +0,90 @@
   28     28   
    }
   29     29   
    /// Returns true if this is a [`Greeting`](crate::types::UnionPayload::Greeting).
   30     30   
    pub fn is_greeting(&self) -> bool {
   31     31   
        self.as_greeting().is_ok()
   32     32   
    }
   33     33   
    /// Returns true if the enum instance is the `Unknown` variant.
   34     34   
    pub fn is_unknown(&self) -> bool {
   35     35   
        matches!(self, Self::Unknown)
   36     36   
    }
   37     37   
}
          38  +
static UNIONPAYLOAD_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
          39  +
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restxml#UnionPayload", "aws.protocoltests.restxml", "UnionPayload");
          40  +
static UNIONPAYLOAD_MEMBER_GREETING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          41  +
    ::aws_smithy_schema::ShapeId::from_static(
          42  +
        "aws.protocoltests.restxml#UnionPayload$greeting",
          43  +
        "aws.protocoltests.restxml",
          44  +
        "UnionPayload",
          45  +
    ),
          46  +
    ::aws_smithy_schema::ShapeType::String,
          47  +
    "greeting",
          48  +
    0,
          49  +
);
          50  +
static UNIONPAYLOAD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          51  +
    UNIONPAYLOAD_SCHEMA_ID,
          52  +
    ::aws_smithy_schema::ShapeType::Union,
          53  +
    &[&UNIONPAYLOAD_MEMBER_GREETING],
          54  +
);
          55  +
impl UnionPayload {
          56  +
    /// The schema for this shape.
          57  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNIONPAYLOAD_SCHEMA;
          58  +
}
          59  +
impl ::aws_smithy_schema::serde::SerializableStruct for UnionPayload {
          60  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          61  +
    fn serialize_members(
          62  +
        &self,
          63  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          64  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          65  +
        match self {
          66  +
            Self::Greeting(val) => {
          67  +
                ser.write_string(&UNIONPAYLOAD_MEMBER_GREETING, val)?;
          68  +
            }
          69  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          70  +
        }
          71  +
        Ok(())
          72  +
    }
          73  +
}
          74  +
impl UnionPayload {
          75  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          78  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          79  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          80  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          81  +
        deserializer.read_struct(&UNIONPAYLOAD_SCHEMA, &mut |member, deser| {
          82  +
            result = ::std::option::Option::Some(match member.member_index() {
          83  +
                Some(0) => Self::Greeting(deser.read_string(member)?),
          84  +
                _ => Self::Unknown,
          85  +
            });
          86  +
            Ok(())
          87  +
        })?;
          88  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
          89  +
    }
          90  +
}

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

@@ -67,67 +156,167 @@
   87     87   
            ser.write_string(&XMLATTRIBUTESINMIDDLEPAYLOADREQUEST_MEMBER_ATTR, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.baz {
   90     90   
            ser.write_string(&XMLATTRIBUTESINMIDDLEPAYLOADREQUEST_MEMBER_BAZ, val)?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl XmlAttributesInMiddlePayloadRequest {
   96     96   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   97         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   98         -
        deserializer: &mut D,
          97  +
    pub fn deserialize(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   99     99   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  100    100   
        #[allow(unused_variables, unused_mut)]
  101    101   
        let mut builder = Self::builder();
  102    102   
        #[allow(
  103    103   
            unused_variables,
  104    104   
            unreachable_code,
  105    105   
            clippy::single_match,
  106    106   
            clippy::match_single_binding,
  107    107   
            clippy::diverging_sub_expression
  108    108   
        )]
  109         -
        deserializer.read_struct(&XMLATTRIBUTESINMIDDLEPAYLOADREQUEST_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&XMLATTRIBUTESINMIDDLEPAYLOADREQUEST_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112    112   
                    builder.foo = Some(deser.read_string(member)?);
  113    113   
                }
  114    114   
                Some(1) => {
  115    115   
                    builder.attr = Some(deser.read_string(member)?);
  116    116   
                }
  117    117   
                Some(2) => {
  118    118   
                    builder.baz = Some(deser.read_string(member)?);
  119    119   
                }
  120    120   
                _ => {}
  121    121   
            }
  122    122   
            Ok(())
  123    123   
        })?;
  124    124   
        Ok(builder.build())
  125    125   
    }
  126    126   
}
         127  +
impl XmlAttributesInMiddlePayloadRequest {
         128  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         129  +
    pub fn deserialize_with_response(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         131  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         132  +
        _status: u16,
         133  +
        _body: &[u8],
         134  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         135  +
        Self::deserialize(deserializer)
         136  +
    }
         137  +
}
  127    138   
impl XmlAttributesInMiddlePayloadRequest {
  128    139   
    /// Creates a new builder-style object to manufacture [`XmlAttributesInMiddlePayloadRequest`](crate::types::XmlAttributesInMiddlePayloadRequest).
  129    140   
    pub fn builder() -> crate::types::builders::XmlAttributesInMiddlePayloadRequestBuilder {
  130    141   
        crate::types::builders::XmlAttributesInMiddlePayloadRequestBuilder::default()
  131    142   
    }
  132    143   
}
  133    144   
  134    145   
/// A builder for [`XmlAttributesInMiddlePayloadRequest`](crate::types::XmlAttributesInMiddlePayloadRequest).
  135    146   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    147   
#[non_exhaustive]

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

@@ -67,67 +156,167 @@
   87     87   
            ser.write_string(&XMLATTRIBUTESINMIDDLEPAYLOADRESPONSE_MEMBER_ATTR, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.baz {
   90     90   
            ser.write_string(&XMLATTRIBUTESINMIDDLEPAYLOADRESPONSE_MEMBER_BAZ, val)?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl XmlAttributesInMiddlePayloadResponse {
   96     96   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   97         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   98         -
        deserializer: &mut D,
          97  +
    pub fn deserialize(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   99     99   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  100    100   
        #[allow(unused_variables, unused_mut)]
  101    101   
        let mut builder = Self::builder();
  102    102   
        #[allow(
  103    103   
            unused_variables,
  104    104   
            unreachable_code,
  105    105   
            clippy::single_match,
  106    106   
            clippy::match_single_binding,
  107    107   
            clippy::diverging_sub_expression
  108    108   
        )]
  109         -
        deserializer.read_struct(&XMLATTRIBUTESINMIDDLEPAYLOADRESPONSE_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&XMLATTRIBUTESINMIDDLEPAYLOADRESPONSE_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112    112   
                    builder.foo = Some(deser.read_string(member)?);
  113    113   
                }
  114    114   
                Some(1) => {
  115    115   
                    builder.attr = Some(deser.read_string(member)?);
  116    116   
                }
  117    117   
                Some(2) => {
  118    118   
                    builder.baz = Some(deser.read_string(member)?);
  119    119   
                }
  120    120   
                _ => {}
  121    121   
            }
  122    122   
            Ok(())
  123    123   
        })?;
  124    124   
        Ok(builder.build())
  125    125   
    }
  126    126   
}
         127  +
impl XmlAttributesInMiddlePayloadResponse {
         128  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         129  +
    pub fn deserialize_with_response(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         131  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         132  +
        _status: u16,
         133  +
        _body: &[u8],
         134  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         135  +
        Self::deserialize(deserializer)
         136  +
    }
         137  +
}
  127    138   
impl XmlAttributesInMiddlePayloadResponse {
  128    139   
    /// Creates a new builder-style object to manufacture [`XmlAttributesInMiddlePayloadResponse`](crate::types::XmlAttributesInMiddlePayloadResponse).
  129    140   
    pub fn builder() -> crate::types::builders::XmlAttributesInMiddlePayloadResponseBuilder {
  130    141   
        crate::types::builders::XmlAttributesInMiddlePayloadResponseBuilder::default()
  131    142   
    }
  132    143   
}
  133    144   
  134    145   
/// A builder for [`XmlAttributesInMiddlePayloadResponse`](crate::types::XmlAttributesInMiddlePayloadResponse).
  135    146   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    147   
#[non_exhaustive]

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

@@ -44,44 +130,141 @@
   64     64   
            ser.write_string(&XMLATTRIBUTESPAYLOADREQUEST_MEMBER_FOO, val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.attr {
   67     67   
            ser.write_string(&XMLATTRIBUTESPAYLOADREQUEST_MEMBER_ATTR, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl XmlAttributesPayloadRequest {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&XMLATTRIBUTESPAYLOADREQUEST_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&XMLATTRIBUTESPAYLOADREQUEST_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.foo = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.attr = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl XmlAttributesPayloadRequest {
         102  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         103  +
    pub fn deserialize_with_response(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         105  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         106  +
        _status: u16,
         107  +
        _body: &[u8],
         108  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         109  +
        Self::deserialize(deserializer)
         110  +
    }
         111  +
}
  101    112   
impl XmlAttributesPayloadRequest {
  102    113   
    /// Creates a new builder-style object to manufacture [`XmlAttributesPayloadRequest`](crate::types::XmlAttributesPayloadRequest).
  103    114   
    pub fn builder() -> crate::types::builders::XmlAttributesPayloadRequestBuilder {
  104    115   
        crate::types::builders::XmlAttributesPayloadRequestBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`XmlAttributesPayloadRequest`](crate::types::XmlAttributesPayloadRequest).
  109    120   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    121   
#[non_exhaustive]

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

@@ -44,44 +130,141 @@
   64     64   
            ser.write_string(&XMLATTRIBUTESPAYLOADRESPONSE_MEMBER_FOO, val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.attr {
   67     67   
            ser.write_string(&XMLATTRIBUTESPAYLOADRESPONSE_MEMBER_ATTR, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl XmlAttributesPayloadResponse {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&XMLATTRIBUTESPAYLOADRESPONSE_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&XMLATTRIBUTESPAYLOADRESPONSE_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.foo = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.attr = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl XmlAttributesPayloadResponse {
         102  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         103  +
    pub fn deserialize_with_response(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         105  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         106  +
        _status: u16,
         107  +
        _body: &[u8],
         108  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         109  +
        Self::deserialize(deserializer)
         110  +
    }
         111  +
}
  101    112   
impl XmlAttributesPayloadResponse {
  102    113   
    /// Creates a new builder-style object to manufacture [`XmlAttributesPayloadResponse`](crate::types::XmlAttributesPayloadResponse).
  103    114   
    pub fn builder() -> crate::types::builders::XmlAttributesPayloadResponseBuilder {
  104    115   
        crate::types::builders::XmlAttributesPayloadResponseBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`XmlAttributesPayloadResponse`](crate::types::XmlAttributesPayloadResponse).
  109    120   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    121   
#[non_exhaustive]

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

@@ -55,55 +151,152 @@
   75     75   
                    }
   76     76   
                    Ok(())
   77     77   
                },
   78     78   
            )?;
   79     79   
        }
   80     80   
        Ok(())
   81     81   
    }
   82     82   
}
   83     83   
impl XmlNamespaceNested {
   84     84   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   85         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   86         -
        deserializer: &mut D,
          85  +
    pub fn deserialize(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   87     87   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        #[allow(unused_variables, unused_mut)]
   89     89   
        let mut builder = Self::builder();
   90     90   
        #[allow(
   91     91   
            unused_variables,
   92     92   
            unreachable_code,
   93     93   
            clippy::single_match,
   94     94   
            clippy::match_single_binding,
   95     95   
            clippy::diverging_sub_expression
   96     96   
        )]
   97         -
        deserializer.read_struct(&XMLNAMESPACENESTED_SCHEMA, (), |_, member, deser| {
          97  +
        deserializer.read_struct(&XMLNAMESPACENESTED_SCHEMA, &mut |member, deser| {
   98     98   
            match member.member_index() {
   99     99   
                Some(0) => {
  100    100   
                    builder.foo = Some(deser.read_string(member)?);
  101    101   
                }
  102    102   
                Some(1) => {
  103         -
                    builder.values = Some({
  104         -
                        let container = if let Some(cap) = deser.container_size() {
  105         -
                            Vec::with_capacity(cap)
  106         -
                        } else {
  107         -
                            Vec::new()
  108         -
                        };
  109         -
                        deser.read_list(member, container, |mut list, deser| {
  110         -
                            list.push(deser.read_string(member)?);
  111         -
                            Ok(list)
  112         -
                        })?
  113         -
                    });
         103  +
                    builder.values = Some(deser.read_string_list(member)?);
  114    104   
                }
  115    105   
                _ => {}
  116    106   
            }
  117    107   
            Ok(())
  118    108   
        })?;
  119    109   
        Ok(builder.build())
  120    110   
    }
  121    111   
}
         112  +
impl XmlNamespaceNested {
         113  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         114  +
    pub fn deserialize_with_response(
         115  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         116  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         117  +
        _status: u16,
         118  +
        _body: &[u8],
         119  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         120  +
        Self::deserialize(deserializer)
         121  +
    }
         122  +
}
  122    123   
impl XmlNamespaceNested {
  123    124   
    /// Creates a new builder-style object to manufacture [`XmlNamespaceNested`](crate::types::XmlNamespaceNested).
  124    125   
    pub fn builder() -> crate::types::builders::XmlNamespaceNestedBuilder {
  125    126   
        crate::types::builders::XmlNamespaceNestedBuilder::default()
  126    127   
    }
  127    128   
}
  128    129   
  129    130   
/// A builder for [`XmlNamespaceNested`](crate::types::XmlNamespaceNested).
  130    131   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  131    132   
#[non_exhaustive]

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

@@ -39,39 +269,280 @@
   59     59   
    "aws.protocoltests.restxml",
   60     60   
    "XmlNestedUnionStruct",
   61     61   
);
   62     62   
static XMLNESTEDUNIONSTRUCT_MEMBER_STRING_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$stringValue",
   65     65   
        "aws.protocoltests.restxml",
   66     66   
        "XmlNestedUnionStruct",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "string_value",
          69  +
    "stringValue",
   70     70   
    0,
   71     71   
);
   72     72   
static XMLNESTEDUNIONSTRUCT_MEMBER_BOOLEAN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$booleanValue",
   75     75   
        "aws.protocoltests.restxml",
   76     76   
        "XmlNestedUnionStruct",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Boolean,
   79         -
    "boolean_value",
          79  +
    "booleanValue",
   80     80   
    1,
   81     81   
);
   82     82   
static XMLNESTEDUNIONSTRUCT_MEMBER_BYTE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$byteValue",
   85     85   
        "aws.protocoltests.restxml",
   86     86   
        "XmlNestedUnionStruct",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::Byte,
   89         -
    "byte_value",
          89  +
    "byteValue",
   90     90   
    2,
   91     91   
);
   92     92   
static XMLNESTEDUNIONSTRUCT_MEMBER_SHORT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$shortValue",
   95     95   
        "aws.protocoltests.restxml",
   96     96   
        "XmlNestedUnionStruct",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Short,
   99         -
    "short_value",
          99  +
    "shortValue",
  100    100   
    3,
  101    101   
);
  102    102   
static XMLNESTEDUNIONSTRUCT_MEMBER_INTEGER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$integerValue",
  105    105   
        "aws.protocoltests.restxml",
  106    106   
        "XmlNestedUnionStruct",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::Integer,
  109         -
    "integer_value",
         109  +
    "integerValue",
  110    110   
    4,
  111    111   
);
  112    112   
static XMLNESTEDUNIONSTRUCT_MEMBER_LONG_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$longValue",
  115    115   
        "aws.protocoltests.restxml",
  116    116   
        "XmlNestedUnionStruct",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::Long,
  119         -
    "long_value",
         119  +
    "longValue",
  120    120   
    5,
  121    121   
);
  122    122   
static XMLNESTEDUNIONSTRUCT_MEMBER_FLOAT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$floatValue",
  125    125   
        "aws.protocoltests.restxml",
  126    126   
        "XmlNestedUnionStruct",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::Float,
  129         -
    "float_value",
         129  +
    "floatValue",
  130    130   
    6,
  131    131   
);
  132    132   
static XMLNESTEDUNIONSTRUCT_MEMBER_DOUBLE_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "aws.protocoltests.restxml#XmlNestedUnionStruct$doubleValue",
  135    135   
        "aws.protocoltests.restxml",
  136    136   
        "XmlNestedUnionStruct",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::Double,
  139         -
    "double_value",
         139  +
    "doubleValue",
  140    140   
    7,
  141    141   
);
  142    142   
static XMLNESTEDUNIONSTRUCT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  143    143   
    XMLNESTEDUNIONSTRUCT_SCHEMA_ID,
  144    144   
    ::aws_smithy_schema::ShapeType::Structure,
  145    145   
    &[
  146    146   
        &XMLNESTEDUNIONSTRUCT_MEMBER_STRING_VALUE,
  147    147   
        &XMLNESTEDUNIONSTRUCT_MEMBER_BOOLEAN_VALUE,
  148    148   
        &XMLNESTEDUNIONSTRUCT_MEMBER_BYTE_VALUE,
  149    149   
        &XMLNESTEDUNIONSTRUCT_MEMBER_SHORT_VALUE,
  150    150   
        &XMLNESTEDUNIONSTRUCT_MEMBER_INTEGER_VALUE,
  151    151   
        &XMLNESTEDUNIONSTRUCT_MEMBER_LONG_VALUE,
  152    152   
        &XMLNESTEDUNIONSTRUCT_MEMBER_FLOAT_VALUE,
  153    153   
        &XMLNESTEDUNIONSTRUCT_MEMBER_DOUBLE_VALUE,
  154    154   
    ],
  155    155   
);
  156    156   
impl XmlNestedUnionStruct {
  157    157   
    /// The schema for this shape.
  158    158   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLNESTEDUNIONSTRUCT_SCHEMA;
  159    159   
}
  160    160   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlNestedUnionStruct {
  161    161   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  162    162   
    fn serialize_members(
  163    163   
        &self,
  164    164   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  165    165   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  166    166   
        if let Some(ref val) = self.string_value {
  167    167   
            ser.write_string(&XMLNESTEDUNIONSTRUCT_MEMBER_STRING_VALUE, val)?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.boolean_value {
  170    170   
            ser.write_boolean(&XMLNESTEDUNIONSTRUCT_MEMBER_BOOLEAN_VALUE, *val)?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.byte_value {
  173    173   
            ser.write_byte(&XMLNESTEDUNIONSTRUCT_MEMBER_BYTE_VALUE, *val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.short_value {
  176    176   
            ser.write_short(&XMLNESTEDUNIONSTRUCT_MEMBER_SHORT_VALUE, *val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.integer_value {
  179    179   
            ser.write_integer(&XMLNESTEDUNIONSTRUCT_MEMBER_INTEGER_VALUE, *val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.long_value {
  182    182   
            ser.write_long(&XMLNESTEDUNIONSTRUCT_MEMBER_LONG_VALUE, *val)?;
  183    183   
        }
  184    184   
        if let Some(ref val) = self.float_value {
  185    185   
            ser.write_float(&XMLNESTEDUNIONSTRUCT_MEMBER_FLOAT_VALUE, *val)?;
  186    186   
        }
  187    187   
        if let Some(ref val) = self.double_value {
  188    188   
            ser.write_double(&XMLNESTEDUNIONSTRUCT_MEMBER_DOUBLE_VALUE, *val)?;
  189    189   
        }
  190    190   
        Ok(())
  191    191   
    }
  192    192   
}
  193    193   
impl XmlNestedUnionStruct {
  194    194   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  195         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  196         -
        deserializer: &mut D,
         195  +
    pub fn deserialize(
         196  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  197    197   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  198    198   
        #[allow(unused_variables, unused_mut)]
  199    199   
        let mut builder = Self::builder();
  200    200   
        #[allow(
  201    201   
            unused_variables,
  202    202   
            unreachable_code,
  203    203   
            clippy::single_match,
  204    204   
            clippy::match_single_binding,
  205    205   
            clippy::diverging_sub_expression
  206    206   
        )]
  207         -
        deserializer.read_struct(&XMLNESTEDUNIONSTRUCT_SCHEMA, (), |_, member, deser| {
         207  +
        deserializer.read_struct(&XMLNESTEDUNIONSTRUCT_SCHEMA, &mut |member, deser| {
  208    208   
            match member.member_index() {
  209    209   
                Some(0) => {
  210    210   
                    builder.string_value = Some(deser.read_string(member)?);
  211    211   
                }
  212    212   
                Some(1) => {
  213    213   
                    builder.boolean_value = Some(deser.read_boolean(member)?);
  214    214   
                }
  215    215   
                Some(2) => {
  216    216   
                    builder.byte_value = Some(deser.read_byte(member)?);
  217    217   
                }
  218    218   
                Some(3) => {
  219    219   
                    builder.short_value = Some(deser.read_short(member)?);
  220    220   
                }
  221    221   
                Some(4) => {
  222    222   
                    builder.integer_value = Some(deser.read_integer(member)?);
  223    223   
                }
  224    224   
                Some(5) => {
  225    225   
                    builder.long_value = Some(deser.read_long(member)?);
  226    226   
                }
  227    227   
                Some(6) => {
  228    228   
                    builder.float_value = Some(deser.read_float(member)?);
  229    229   
                }
  230    230   
                Some(7) => {
  231    231   
                    builder.double_value = Some(deser.read_double(member)?);
  232    232   
                }
  233    233   
                _ => {}
  234    234   
            }
  235    235   
            Ok(())
  236    236   
        })?;
  237    237   
        Ok(builder.build())
  238    238   
    }
  239    239   
}
         240  +
impl XmlNestedUnionStruct {
         241  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         242  +
    pub fn deserialize_with_response(
         243  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         244  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         245  +
        _status: u16,
         246  +
        _body: &[u8],
         247  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         248  +
        Self::deserialize(deserializer)
         249  +
    }
         250  +
}
  240    251   
impl XmlNestedUnionStruct {
  241    252   
    /// Creates a new builder-style object to manufacture [`XmlNestedUnionStruct`](crate::types::XmlNestedUnionStruct).
  242    253   
    pub fn builder() -> crate::types::builders::XmlNestedUnionStructBuilder {
  243    254   
        crate::types::builders::XmlNestedUnionStructBuilder::default()
  244    255   
    }
  245    256   
}
  246    257   
  247    258   
/// A builder for [`XmlNestedUnionStruct`](crate::types::XmlNestedUnionStruct).
  248    259   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  249    260   
#[non_exhaustive]

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

@@ -142,142 +0,361 @@
  162    162   
    }
  163    163   
    /// Returns true if this is a [`UnionValue`](crate::types::XmlUnionShape::UnionValue).
  164    164   
    pub fn is_union_value(&self) -> bool {
  165    165   
        self.as_union_value().is_ok()
  166    166   
    }
  167    167   
    /// Returns true if the enum instance is the `Unknown` variant.
  168    168   
    pub fn is_unknown(&self) -> bool {
  169    169   
        matches!(self, Self::Unknown)
  170    170   
    }
  171    171   
}
         172  +
static XMLUNIONSHAPE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
         173  +
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restxml#XmlUnionShape", "aws.protocoltests.restxml", "XmlUnionShape");
         174  +
static XMLUNIONSHAPE_MEMBER_STRINGVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         175  +
    ::aws_smithy_schema::ShapeId::from_static(
         176  +
        "aws.protocoltests.restxml#XmlUnionShape$stringValue",
         177  +
        "aws.protocoltests.restxml",
         178  +
        "XmlUnionShape",
         179  +
    ),
         180  +
    ::aws_smithy_schema::ShapeType::String,
         181  +
    "stringValue",
         182  +
    0,
         183  +
);
         184  +
static XMLUNIONSHAPE_MEMBER_BOOLEANVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         185  +
    ::aws_smithy_schema::ShapeId::from_static(
         186  +
        "aws.protocoltests.restxml#XmlUnionShape$booleanValue",
         187  +
        "aws.protocoltests.restxml",
         188  +
        "XmlUnionShape",
         189  +
    ),
         190  +
    ::aws_smithy_schema::ShapeType::Boolean,
         191  +
    "booleanValue",
         192  +
    1,
         193  +
);
         194  +
static XMLUNIONSHAPE_MEMBER_BYTEVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         195  +
    ::aws_smithy_schema::ShapeId::from_static(
         196  +
        "aws.protocoltests.restxml#XmlUnionShape$byteValue",
         197  +
        "aws.protocoltests.restxml",
         198  +
        "XmlUnionShape",
         199  +
    ),
         200  +
    ::aws_smithy_schema::ShapeType::Byte,
         201  +
    "byteValue",
         202  +
    2,
         203  +
);
         204  +
static XMLUNIONSHAPE_MEMBER_SHORTVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         205  +
    ::aws_smithy_schema::ShapeId::from_static(
         206  +
        "aws.protocoltests.restxml#XmlUnionShape$shortValue",
         207  +
        "aws.protocoltests.restxml",
         208  +
        "XmlUnionShape",
         209  +
    ),
         210  +
    ::aws_smithy_schema::ShapeType::Short,
         211  +
    "shortValue",
         212  +
    3,
         213  +
);
         214  +
static XMLUNIONSHAPE_MEMBER_INTEGERVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         215  +
    ::aws_smithy_schema::ShapeId::from_static(
         216  +
        "aws.protocoltests.restxml#XmlUnionShape$integerValue",
         217  +
        "aws.protocoltests.restxml",
         218  +
        "XmlUnionShape",
         219  +
    ),
         220  +
    ::aws_smithy_schema::ShapeType::Integer,
         221  +
    "integerValue",
         222  +
    4,
         223  +
);
         224  +
static XMLUNIONSHAPE_MEMBER_LONGVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         225  +
    ::aws_smithy_schema::ShapeId::from_static(
         226  +
        "aws.protocoltests.restxml#XmlUnionShape$longValue",
         227  +
        "aws.protocoltests.restxml",
         228  +
        "XmlUnionShape",
         229  +
    ),
         230  +
    ::aws_smithy_schema::ShapeType::Long,
         231  +
    "longValue",
         232  +
    5,
         233  +
);
         234  +
static XMLUNIONSHAPE_MEMBER_FLOATVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         235  +
    ::aws_smithy_schema::ShapeId::from_static(
         236  +
        "aws.protocoltests.restxml#XmlUnionShape$floatValue",
         237  +
        "aws.protocoltests.restxml",
         238  +
        "XmlUnionShape",
         239  +
    ),
         240  +
    ::aws_smithy_schema::ShapeType::Float,
         241  +
    "floatValue",
         242  +
    6,
         243  +
);
         244  +
static XMLUNIONSHAPE_MEMBER_DOUBLEVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         245  +
    ::aws_smithy_schema::ShapeId::from_static(
         246  +
        "aws.protocoltests.restxml#XmlUnionShape$doubleValue",
         247  +
        "aws.protocoltests.restxml",
         248  +
        "XmlUnionShape",
         249  +
    ),
         250  +
    ::aws_smithy_schema::ShapeType::Double,
         251  +
    "doubleValue",
         252  +
    7,
         253  +
);
         254  +
static XMLUNIONSHAPE_MEMBER_UNIONVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         255  +
    ::aws_smithy_schema::ShapeId::from_static(
         256  +
        "aws.protocoltests.restxml#XmlUnionShape$unionValue",
         257  +
        "aws.protocoltests.restxml",
         258  +
        "XmlUnionShape",
         259  +
    ),
         260  +
    ::aws_smithy_schema::ShapeType::Union,
         261  +
    "unionValue",
         262  +
    8,
         263  +
);
         264  +
static XMLUNIONSHAPE_MEMBER_STRUCTVALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         265  +
    ::aws_smithy_schema::ShapeId::from_static(
         266  +
        "aws.protocoltests.restxml#XmlUnionShape$structValue",
         267  +
        "aws.protocoltests.restxml",
         268  +
        "XmlUnionShape",
         269  +
    ),
         270  +
    ::aws_smithy_schema::ShapeType::Structure,
         271  +
    "structValue",
         272  +
    9,
         273  +
);
         274  +
static XMLUNIONSHAPE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         275  +
    XMLUNIONSHAPE_SCHEMA_ID,
         276  +
    ::aws_smithy_schema::ShapeType::Union,
         277  +
    &[
         278  +
        &XMLUNIONSHAPE_MEMBER_STRINGVALUE,
         279  +
        &XMLUNIONSHAPE_MEMBER_BOOLEANVALUE,
         280  +
        &XMLUNIONSHAPE_MEMBER_BYTEVALUE,
         281  +
        &XMLUNIONSHAPE_MEMBER_SHORTVALUE,
         282  +
        &XMLUNIONSHAPE_MEMBER_INTEGERVALUE,
         283  +
        &XMLUNIONSHAPE_MEMBER_LONGVALUE,
         284  +
        &XMLUNIONSHAPE_MEMBER_FLOATVALUE,
         285  +
        &XMLUNIONSHAPE_MEMBER_DOUBLEVALUE,
         286  +
        &XMLUNIONSHAPE_MEMBER_UNIONVALUE,
         287  +
        &XMLUNIONSHAPE_MEMBER_STRUCTVALUE,
         288  +
    ],
         289  +
);
         290  +
impl XmlUnionShape {
         291  +
    /// The schema for this shape.
         292  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLUNIONSHAPE_SCHEMA;
         293  +
}
         294  +
impl ::aws_smithy_schema::serde::SerializableStruct for XmlUnionShape {
         295  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         296  +
    fn serialize_members(
         297  +
        &self,
         298  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         299  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         300  +
        match self {
         301  +
            Self::StringValue(val) => {
         302  +
                ser.write_string(&XMLUNIONSHAPE_MEMBER_STRINGVALUE, val)?;
         303  +
            }
         304  +
            Self::BooleanValue(val) => {
         305  +
                ser.write_boolean(&XMLUNIONSHAPE_MEMBER_BOOLEANVALUE, *val)?;
         306  +
            }
         307  +
            Self::ByteValue(val) => {
         308  +
                ser.write_byte(&XMLUNIONSHAPE_MEMBER_BYTEVALUE, *val)?;
         309  +
            }
         310  +
            Self::ShortValue(val) => {
         311  +
                ser.write_short(&XMLUNIONSHAPE_MEMBER_SHORTVALUE, *val)?;
         312  +
            }
         313  +
            Self::IntegerValue(val) => {
         314  +
                ser.write_integer(&XMLUNIONSHAPE_MEMBER_INTEGERVALUE, *val)?;
         315  +
            }
         316  +
            Self::LongValue(val) => {
         317  +
                ser.write_long(&XMLUNIONSHAPE_MEMBER_LONGVALUE, *val)?;
         318  +
            }
         319  +
            Self::FloatValue(val) => {
         320  +
                ser.write_float(&XMLUNIONSHAPE_MEMBER_FLOATVALUE, *val)?;
         321  +
            }
         322  +
            Self::DoubleValue(val) => {
         323  +
                ser.write_double(&XMLUNIONSHAPE_MEMBER_DOUBLEVALUE, *val)?;
         324  +
            }
         325  +
            Self::UnionValue(val) => {
         326  +
                ser.write_struct(&XMLUNIONSHAPE_MEMBER_UNIONVALUE, val)?;
         327  +
            }
         328  +
            Self::StructValue(val) => {
         329  +
                ser.write_struct(&XMLUNIONSHAPE_MEMBER_STRUCTVALUE, val)?;
         330  +
            }
         331  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         332  +
        }
         333  +
        Ok(())
         334  +
    }
         335  +
}
         336  +
impl XmlUnionShape {
         337  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         338  +
    pub fn deserialize(
         339  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         340  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         341  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         342  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         343  +
        deserializer.read_struct(&XMLUNIONSHAPE_SCHEMA, &mut |member, deser| {
         344  +
            result = ::std::option::Option::Some(match member.member_index() {
         345  +
                Some(0) => Self::StringValue(deser.read_string(member)?),
         346  +
                Some(1) => Self::BooleanValue(deser.read_boolean(member)?),
         347  +
                Some(2) => Self::ByteValue(deser.read_byte(member)?),
         348  +
                Some(3) => Self::ShortValue(deser.read_short(member)?),
         349  +
                Some(4) => Self::IntegerValue(deser.read_integer(member)?),
         350  +
                Some(5) => Self::LongValue(deser.read_long(member)?),
         351  +
                Some(6) => Self::FloatValue(deser.read_float(member)?),
         352  +
                Some(7) => Self::DoubleValue(deser.read_double(member)?),
         353  +
                Some(8) => Self::UnionValue(Box::new(crate::types::XmlUnionShape::deserialize(deser)?)),
         354  +
                Some(9) => Self::StructValue(crate::types::XmlNestedUnionStruct::deserialize(deser)?),
         355  +
                _ => Self::Unknown,
         356  +
            });
         357  +
            Ok(())
         358  +
        })?;
         359  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         360  +
    }
         361  +
}

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

@@ -8,8 +150,188 @@
   28     28   
}
   29     29   
static COMPLEXERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   30     30   
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restxml#ComplexError", "aws.protocoltests.restxml", "ComplexError");
   31     31   
static COMPLEXERROR_MEMBER_HEADER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "aws.protocoltests.restxml#ComplexError$Header",
   34     34   
        "aws.protocoltests.restxml",
   35     35   
        "ComplexError",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::String,
   38         -
    "header",
          38  +
    "Header",
   39     39   
    0,
   40     40   
)
   41     41   
.with_http_header("X-Header");
   42     42   
static COMPLEXERROR_MEMBER_TOP_LEVEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "aws.protocoltests.restxml#ComplexError$TopLevel",
   45     45   
        "aws.protocoltests.restxml",
   46     46   
        "ComplexError",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "top_level",
          49  +
    "TopLevel",
   50     50   
    1,
   51     51   
);
   52     52   
static COMPLEXERROR_MEMBER_NESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "aws.protocoltests.restxml#ComplexError$Nested",
   55     55   
        "aws.protocoltests.restxml",
   56     56   
        "ComplexError",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Structure,
   59         -
    "nested",
          59  +
    "Nested",
   60     60   
    2,
   61     61   
);
   62     62   
static COMPLEXERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    COMPLEXERROR_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[&COMPLEXERROR_MEMBER_HEADER, &COMPLEXERROR_MEMBER_TOP_LEVEL, &COMPLEXERROR_MEMBER_NESTED],
   66     66   
);
   67     67   
impl ComplexError {
   68     68   
    /// The schema for this shape.
   69     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLEXERROR_SCHEMA;
   70     70   
}
   71     71   
impl ::aws_smithy_schema::serde::SerializableStruct for ComplexError {
   72     72   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   73     73   
    fn serialize_members(
   74     74   
        &self,
   75     75   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   76     76   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        if let Some(ref val) = self.header {
   78     78   
            ser.write_string(&COMPLEXERROR_MEMBER_HEADER, val)?;
   79     79   
        }
   80     80   
        if let Some(ref val) = self.top_level {
   81     81   
            ser.write_string(&COMPLEXERROR_MEMBER_TOP_LEVEL, val)?;
   82     82   
        }
   83     83   
        if let Some(ref val) = self.nested {
   84     84   
            ser.write_struct(&COMPLEXERROR_MEMBER_NESTED, val)?;
   85     85   
        }
   86     86   
        Ok(())
   87     87   
    }
   88     88   
}
   89     89   
impl ComplexError {
   90     90   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   91         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   92         -
        deserializer: &mut D,
          91  +
    pub fn deserialize(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   93     93   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   94     94   
        #[allow(unused_variables, unused_mut)]
   95     95   
        let mut builder = Self::builder();
   96     96   
        #[allow(
   97     97   
            unused_variables,
   98     98   
            unreachable_code,
   99     99   
            clippy::single_match,
  100    100   
            clippy::match_single_binding,
  101    101   
            clippy::diverging_sub_expression
  102    102   
        )]
  103         -
        deserializer.read_struct(&COMPLEXERROR_SCHEMA, (), |_, member, deser| {
         103  +
        deserializer.read_struct(&COMPLEXERROR_SCHEMA, &mut |member, deser| {
  104    104   
            match member.member_index() {
  105    105   
                Some(0) => {
  106    106   
                    builder.header = Some(deser.read_string(member)?);
  107    107   
                }
  108    108   
                Some(1) => {
  109    109   
                    builder.top_level = Some(deser.read_string(member)?);
  110    110   
                }
  111    111   
                Some(2) => {
  112    112   
                    builder.nested = Some(crate::types::ComplexNestedErrorData::deserialize(deser)?);
  113    113   
                }
  114    114   
                _ => {}
  115    115   
            }
  116    116   
            Ok(())
  117    117   
        })?;
  118    118   
        Ok(builder.build())
  119    119   
    }
  120    120   
}
         121  +
impl ComplexError {
         122  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         123  +
    /// Header-bound members are read directly from headers, avoiding runtime
         124  +
    /// member iteration overhead. Body members are read via the deserializer.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        #[allow(unused_variables, unused_mut)]
         132  +
        let mut builder = Self::builder();
         133  +
        if let Some(val) = headers.get("X-Header") {
         134  +
            builder.header = Some(val.to_string());
         135  +
        }
         136  +
        #[allow(
         137  +
            unused_variables,
         138  +
            unreachable_code,
         139  +
            clippy::single_match,
         140  +
            clippy::match_single_binding,
         141  +
            clippy::diverging_sub_expression
         142  +
        )]
         143  +
        deserializer.read_struct(&COMPLEXERROR_SCHEMA, &mut |member, deser| {
         144  +
            match member.member_index() {
         145  +
                Some(0) => { /* read from headers above */ }
         146  +
                Some(1) => {
         147  +
                    builder.top_level = Some(deser.read_string(member)?);
         148  +
                }
         149  +
                Some(2) => {
         150  +
                    builder.nested = Some(crate::types::ComplexNestedErrorData::deserialize(deser)?);
         151  +
                }
         152  +
                _ => {}
         153  +
            }
         154  +
            Ok(())
         155  +
        })?;
         156  +
        Ok(builder.build())
         157  +
    }
         158  +
}
  121    159   
impl ComplexError {}
  122    160   
impl ::std::fmt::Display for ComplexError {
  123    161   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  124    162   
        ::std::write!(f, "ComplexError")?;
  125    163   
        Ok(())
  126    164   
    }
  127    165   
}
  128    166   
impl ::std::error::Error for ComplexError {}
  129    167   
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ComplexError {
  130    168   
    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {

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

@@ -1,1 +102,113 @@
   13     13   
    "aws.protocoltests.restxml",
   14     14   
    "InvalidGreeting",
   15     15   
);
   16     16   
static INVALIDGREETING_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "aws.protocoltests.restxml#InvalidGreeting$Message",
   19     19   
        "aws.protocoltests.restxml",
   20     20   
        "InvalidGreeting",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static INVALIDGREETING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    INVALIDGREETING_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&INVALIDGREETING_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl InvalidGreeting {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDGREETING_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidGreeting {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&INVALIDGREETING_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl InvalidGreeting {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&INVALIDGREETING_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&INVALIDGREETING_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl InvalidGreeting {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl InvalidGreeting {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for InvalidGreeting {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "InvalidGreeting")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/attribute_party.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `AttributeParty`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AttributeParty;
    6      6   
impl AttributeParty {
    7      7   
    /// Creates a new `AttributeParty`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::attribute_party::AttributePartyInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::attribute_party::AttributePartyOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::attribute_party::AttributePartyInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::attribute_party::AttributePartyOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::attribute_party::AttributePartyError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::attribute_party::AttributePartyError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct AttributePartyResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AttributePartyResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_attribute_party::de_attribute_party_http_error(status, headers, body)
  146    151   
        } else {
@@ -244,249 +304,313 @@
  264    269   
            .expect("the config must have a deserializer");
  265    270   
  266    271   
        let parsed = de.deserialize_streaming(&mut http_response);
  267    272   
        let parsed = parsed.unwrap_or_else(|| {
  268    273   
            let http_response = http_response.map(|body| {
  269    274   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  270    275   
                    body.bytes().unwrap(),
  271    276   
                    ::aws_smithy_protocol_test::MediaType::from("unknown"),
  272    277   
                )))
  273    278   
            });
  274         -
            de.deserialize_nonstreaming(&http_response)
         279  +
            // Build a config bag with the protocol for schema-based deserialization
         280  +
            #[allow(unused_mut)]
         281  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         282  +
         283  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  275    284   
        });
  276    285   
        let parsed = parsed
  277    286   
            .expect("should be successful response")
  278    287   
            .downcast::<crate::operation::attribute_party::AttributePartyOutput>()
  279    288   
            .unwrap();
  280    289   
        ::pretty_assertions::assert_eq!(parsed.r#enum, expected_output.r#enum, "Unexpected value for `r#enum`");
  281    290   
        ::pretty_assertions::assert_eq!(parsed.number, expected_output.number, "Unexpected value for `number`");
  282    291   
        ::pretty_assertions::assert_eq!(parsed.ts, expected_output.ts, "Unexpected value for `ts`");
  283    292   
        ::pretty_assertions::assert_eq!(parsed.bool, expected_output.bool, "Unexpected value for `bool`");
  284    293   
    }

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/attribute_party/_attribute_party_input.rs

@@ -1,1 +69,83 @@
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3      3   
#[non_exhaustive]
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct AttributePartyInput {}
    6      6   
static ATTRIBUTEPARTYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
    7      7   
    "aws.protocoltests.restxml.synthetic#AttributePartyInput",
    8      8   
    "aws.protocoltests.restxml.synthetic",
    9      9   
    "AttributePartyInput",
   10     10   
);
   11     11   
static ATTRIBUTEPARTYINPUT_SCHEMA: ::aws_smithy_schema::Schema =
   12         -
    ::aws_smithy_schema::Schema::new_struct(ATTRIBUTEPARTYINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          12  +
    ::aws_smithy_schema::Schema::new_struct(ATTRIBUTEPARTYINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
          13  +
        .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/AttributeParty", None));
   13     14   
impl AttributePartyInput {
   14     15   
    /// The schema for this shape.
   15     16   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ATTRIBUTEPARTYINPUT_SCHEMA;
   16     17   
}
   17     18   
impl ::aws_smithy_schema::serde::SerializableStruct for AttributePartyInput {
   18     19   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     20   
    fn serialize_members(
   20     21   
        &self,
   21     22   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     23   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     24   
        Ok(())
   24     25   
    }
   25     26   
}
   26     27   
impl AttributePartyInput {
   27     28   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          29  +
    pub fn deserialize(
          30  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     31   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     32   
        #[allow(unused_variables, unused_mut)]
   32     33   
        let mut builder = Self::builder();
   33     34   
        #[allow(
   34     35   
            unused_variables,
   35     36   
            unreachable_code,
   36     37   
            clippy::single_match,
   37     38   
            clippy::match_single_binding,
   38     39   
            clippy::diverging_sub_expression
   39     40   
        )]
   40         -
        deserializer.read_struct(&ATTRIBUTEPARTYINPUT_SCHEMA, (), |_, member, deser| {
          41  +
        deserializer.read_struct(&ATTRIBUTEPARTYINPUT_SCHEMA, &mut |member, deser| {
   41     42   
            match member.member_index() {
   42     43   
                _ => {}
   43     44   
            }
   44     45   
            Ok(())
   45     46   
        })?;
   46     47   
        builder
   47     48   
            .build()
   48     49   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   49     50   
    }
   50     51   
}
          52  +
impl AttributePartyInput {
          53  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          54  +
    pub fn deserialize_with_response(
          55  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          56  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          57  +
        _status: u16,
          58  +
        _body: &[u8],
          59  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          60  +
        Self::builder()
          61  +
            .build()
          62  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          63  +
    }
          64  +
}
   51     65   
impl AttributePartyInput {
   52     66   
    /// Creates a new builder-style object to manufacture [`AttributePartyInput`](crate::operation::attribute_party::AttributePartyInput).
   53     67   
    pub fn builder() -> crate::operation::attribute_party::builders::AttributePartyInputBuilder {
   54     68   
        crate::operation::attribute_party::builders::AttributePartyInputBuilder::default()
   55     69   
    }
   56     70   
}
   57     71   
   58     72   
/// A builder for [`AttributePartyInput`](crate::operation::attribute_party::AttributePartyInput).
   59     73   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   60     74   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/attribute_party/_attribute_party_output.rs

@@ -15,15 +75,75 @@
   35     35   
    "aws.protocoltests.restxml.synthetic",
   36     36   
    "AttributePartyOutput",
   37     37   
);
   38     38   
static ATTRIBUTEPARTYOUTPUT_MEMBER_ENUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "aws.protocoltests.restxml.synthetic#AttributePartyOutput$enum",
   41     41   
        "aws.protocoltests.restxml.synthetic",
   42     42   
        "AttributePartyOutput",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "r##enum",
          45  +
    "enum",
   46     46   
    0,
   47     47   
)
   48     48   
.with_xml_attribute();
   49     49   
static ATTRIBUTEPARTYOUTPUT_MEMBER_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "aws.protocoltests.restxml.synthetic#AttributePartyOutput$number",
   52     52   
        "aws.protocoltests.restxml.synthetic",
   53     53   
        "AttributePartyOutput",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::Integer,
@@ -90,90 +182,193 @@
  110    110   
            ser.write_timestamp(&ATTRIBUTEPARTYOUTPUT_MEMBER_TS, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.bool {
  113    113   
            ser.write_boolean(&ATTRIBUTEPARTYOUTPUT_MEMBER_BOOL, *val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl AttributePartyOutput {
  119    119   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         120  +
    pub fn deserialize(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    122   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        #[allow(unused_variables, unused_mut)]
  124    124   
        let mut builder = Self::builder();
  125    125   
        #[allow(
  126    126   
            unused_variables,
  127    127   
            unreachable_code,
  128    128   
            clippy::single_match,
  129    129   
            clippy::match_single_binding,
  130    130   
            clippy::diverging_sub_expression
  131    131   
        )]
  132         -
        deserializer.read_struct(&ATTRIBUTEPARTYOUTPUT_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&ATTRIBUTEPARTYOUTPUT_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.r#enum = Some(crate::types::StringEnum::from(deser.read_string(member)?.as_str()));
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.number = Some(deser.read_integer(member)?);
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.ts = Some(deser.read_timestamp(member)?);
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.bool = Some(deser.read_boolean(member)?);
  145    145   
                }
  146    146   
                _ => {}
  147    147   
            }
  148    148   
            Ok(())
  149    149   
        })?;
  150    150   
        Ok(builder.build())
  151    151   
    }
  152    152   
}
         153  +
impl AttributePartyOutput {
         154  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         155  +
    pub fn deserialize_with_response(
         156  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         157  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         158  +
        _status: u16,
         159  +
        _body: &[u8],
         160  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         161  +
        Self::deserialize(deserializer)
         162  +
    }
         163  +
}
  153    164   
impl AttributePartyOutput {
  154    165   
    /// Creates a new builder-style object to manufacture [`AttributePartyOutput`](crate::operation::attribute_party::AttributePartyOutput).
  155    166   
    pub fn builder() -> crate::operation::attribute_party::builders::AttributePartyOutputBuilder {
  156    167   
        crate::operation::attribute_party::builders::AttributePartyOutputBuilder::default()
  157    168   
    }
  158    169   
}
  159    170   
  160    171   
/// A builder for [`AttributePartyOutput`](crate::operation::attribute_party::AttributePartyOutput).
  161    172   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  162    173   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/checksum_required.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `ChecksumRequired`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ChecksumRequired;
    6      6   
impl ChecksumRequired {
    7      7   
    /// Creates a new `ChecksumRequired`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::checksum_required::ChecksumRequiredInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::checksum_required::ChecksumRequiredOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::checksum_required::ChecksumRequiredInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::checksum_required::ChecksumRequiredOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::checksum_required::ChecksumRequiredError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -110,114 +172,177 @@
  130    134   
                crate::operation::checksum_required::ChecksumRequiredError,
  131    135   
            >::new());
  132    136   
  133    137   
        ::std::borrow::Cow::Owned(rcb)
  134    138   
    }
  135    139   
}
  136    140   
  137    141   
#[derive(Debug)]
  138    142   
struct ChecksumRequiredResponseDeserializer;
  139    143   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ChecksumRequiredResponseDeserializer {
  140         -
    fn deserialize_nonstreaming(
         144  +
    fn deserialize_nonstreaming_with_config(
  141    145   
        &self,
  142    146   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         147  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  143    148   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  144    149   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  145    150   
        let headers = response.headers();
  146    151   
        let body = response.body().bytes().expect("body loaded");
  147    152   
        #[allow(unused_mut)]
  148    153   
        let mut force_error = false;
  149    154   
  150    155   
        let parse_result = if !success && status != 200 || force_error {
  151    156   
            crate::protocol_serde::shape_checksum_required::de_checksum_required_http_error(status, headers, body)
  152    157   
        } else {

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/checksum_required/_checksum_required_input.rs

@@ -4,4 +108,120 @@
   24     24   
        "ChecksumRequiredInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27     27   
    "field",
   28     28   
    0,
   29     29   
);
   30     30   
static CHECKSUMREQUIREDINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    CHECKSUMREQUIREDINPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&CHECKSUMREQUIREDINPUT_MEMBER_FIELD],
   34         -
);
          34  +
)
          35  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/ChecksumRequired", None));
   35     36   
impl ChecksumRequiredInput {
   36     37   
    /// The schema for this shape.
   37     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CHECKSUMREQUIREDINPUT_SCHEMA;
   38     39   
}
   39     40   
impl ::aws_smithy_schema::serde::SerializableStruct for ChecksumRequiredInput {
   40     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     42   
    fn serialize_members(
   42     43   
        &self,
   43     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     46   
        if let Some(ref val) = self.field {
   46     47   
            ser.write_string(&CHECKSUMREQUIREDINPUT_MEMBER_FIELD, val)?;
   47     48   
        }
   48     49   
        Ok(())
   49     50   
    }
   50     51   
}
   51     52   
impl ChecksumRequiredInput {
   52     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     57   
        #[allow(unused_variables, unused_mut)]
   57     58   
        let mut builder = Self::builder();
   58     59   
        #[allow(
   59     60   
            unused_variables,
   60     61   
            unreachable_code,
   61     62   
            clippy::single_match,
   62     63   
            clippy::match_single_binding,
   63     64   
            clippy::diverging_sub_expression
   64     65   
        )]
   65         -
        deserializer.read_struct(&CHECKSUMREQUIREDINPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&CHECKSUMREQUIREDINPUT_SCHEMA, &mut |member, deser| {
   66     67   
            match member.member_index() {
   67     68   
                Some(0) => {
   68     69   
                    builder.field = Some(deser.read_string(member)?);
   69     70   
                }
   70     71   
                _ => {}
   71     72   
            }
   72     73   
            Ok(())
   73     74   
        })?;
   74     75   
        builder
   75     76   
            .build()
   76     77   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     78   
    }
   78     79   
}
          80  +
impl ChecksumRequiredInput {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          82  +
    pub fn deserialize_with_response(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   79     91   
impl ChecksumRequiredInput {
   80     92   
    /// Creates a new builder-style object to manufacture [`ChecksumRequiredInput`](crate::operation::checksum_required::ChecksumRequiredInput).
   81     93   
    pub fn builder() -> crate::operation::checksum_required::builders::ChecksumRequiredInputBuilder {
   82     94   
        crate::operation::checksum_required::builders::ChecksumRequiredInputBuilder::default()
   83     95   
    }
   84     96   
}
   85     97   
   86     98   
/// A builder for [`ChecksumRequiredInput`](crate::operation::checksum_required::ChecksumRequiredInput).
   87     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88    100   
#[non_exhaustive]