Client Test

Client Test

rev. 163d4d6410694aaf071424777ecbecd050925f36

Files changed:

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

@@ -24,24 +107,118 @@
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.name {
   47     47   
            ser.write_string(&PAYLOADWITHXMLNAMESPACE_MEMBER_NAME, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl PayloadWithXmlNamespace {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&PAYLOADWITHXMLNAMESPACE_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&PAYLOADWITHXMLNAMESPACE_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.name = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl PayloadWithXmlNamespace {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl PayloadWithXmlNamespace {
   79     90   
    /// Creates a new builder-style object to manufacture [`PayloadWithXmlNamespace`](crate::types::PayloadWithXmlNamespace).
   80     91   
    pub fn builder() -> crate::types::builders::PayloadWithXmlNamespaceBuilder {
   81     92   
        crate::types::builders::PayloadWithXmlNamespaceBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`PayloadWithXmlNamespace`](crate::types::PayloadWithXmlNamespace).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

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

@@ -24,24 +107,118 @@
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.name {
   47     47   
            ser.write_string(&PAYLOADWITHXMLNAMESPACEANDPREFIX_MEMBER_NAME, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl PayloadWithXmlNamespaceAndPrefix {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&PAYLOADWITHXMLNAMESPACEANDPREFIX_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&PAYLOADWITHXMLNAMESPACEANDPREFIX_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.name = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl PayloadWithXmlNamespaceAndPrefix {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl PayloadWithXmlNamespaceAndPrefix {
   79     90   
    /// Creates a new builder-style object to manufacture [`PayloadWithXmlNamespaceAndPrefix`](crate::types::PayloadWithXmlNamespaceAndPrefix).
   80     91   
    pub fn builder() -> crate::types::builders::PayloadWithXmlNamespaceAndPrefixBuilder {
   81     92   
        crate::types::builders::PayloadWithXmlNamespaceAndPrefixBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`PayloadWithXmlNamespaceAndPrefix`](crate::types::PayloadWithXmlNamespaceAndPrefix).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

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

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

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

@@ -13,13 +131,142 @@
   33     33   
    "bar",
   34     34   
    0,
   35     35   
);
   36     36   
static RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_RECURSIVE_MEMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "aws.protocoltests.restxml#RecursiveShapesInputOutputNested2$recursiveMember",
   39     39   
        "aws.protocoltests.restxml",
   40     40   
        "RecursiveShapesInputOutputNested2",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43         -
    "recursive_member",
          43  +
    "recursiveMember",
   44     44   
    1,
   45     45   
);
   46     46   
static RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   47     47   
    RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA_ID,
   48     48   
    ::aws_smithy_schema::ShapeType::Structure,
   49     49   
    &[
   50     50   
        &RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_BAR,
   51     51   
        &RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_RECURSIVE_MEMBER,
   52     52   
    ],
   53     53   
);
   54     54   
impl RecursiveShapesInputOutputNested2 {
   55     55   
    /// The schema for this shape.
   56     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA;
   57     57   
}
   58     58   
impl ::aws_smithy_schema::serde::SerializableStruct for RecursiveShapesInputOutputNested2 {
   59     59   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   60     60   
    fn serialize_members(
   61     61   
        &self,
   62     62   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   63     63   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   64     64   
        if let Some(ref val) = self.bar {
   65     65   
            ser.write_string(&RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_BAR, val)?;
   66     66   
        }
   67     67   
        if let Some(ref val) = self.recursive_member {
   68     68   
            ser.write_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED2_MEMBER_RECURSIVE_MEMBER, val)?;
   69     69   
        }
   70     70   
        Ok(())
   71     71   
    }
   72     72   
}
   73     73   
impl RecursiveShapesInputOutputNested2 {
   74     74   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   75         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   76         -
        deserializer: &mut D,
          75  +
    pub fn deserialize(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   77     77   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   78     78   
        #[allow(unused_variables, unused_mut)]
   79     79   
        let mut builder = Self::builder();
   80     80   
        #[allow(
   81     81   
            unused_variables,
   82     82   
            unreachable_code,
   83     83   
            clippy::single_match,
   84     84   
            clippy::match_single_binding,
   85     85   
            clippy::diverging_sub_expression
   86     86   
        )]
   87         -
        deserializer.read_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA, (), |_, member, deser| {
          87  +
        deserializer.read_struct(&RECURSIVESHAPESINPUTOUTPUTNESTED2_SCHEMA, &mut |member, deser| {
   88     88   
            match member.member_index() {
   89     89   
                Some(0) => {
   90     90   
                    builder.bar = Some(deser.read_string(member)?);
   91     91   
                }
   92     92   
                Some(1) => {
   93     93   
                    builder.recursive_member = Some(crate::types::RecursiveShapesInputOutputNested1::deserialize(deser)?);
   94     94   
                }
   95     95   
                _ => {}
   96     96   
            }
   97     97   
            Ok(())
   98     98   
        })?;
   99     99   
        Ok(builder.build())
  100    100   
    }
  101    101   
}
         102  +
impl RecursiveShapesInputOutputNested2 {
         103  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         104  +
    pub fn deserialize_with_response(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         106  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         107  +
        _status: u16,
         108  +
        _body: &[u8],
         109  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         110  +
        Self::deserialize(deserializer)
         111  +
    }
         112  +
}
  102    113   
impl RecursiveShapesInputOutputNested2 {
  103    114   
    /// Creates a new builder-style object to manufacture [`RecursiveShapesInputOutputNested2`](crate::types::RecursiveShapesInputOutputNested2).
  104    115   
    pub fn builder() -> crate::types::builders::RecursiveShapesInputOutputNested2Builder {
  105    116   
        crate::types::builders::RecursiveShapesInputOutputNested2Builder::default()
  106    117   
    }
  107    118   
}
  108    119   
  109    120   
/// A builder for [`RecursiveShapesInputOutputNested2`](crate::types::RecursiveShapesInputOutputNested2).
  110    121   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    122   
#[non_exhaustive]

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   
    > {
@@ -107,111 +166,171 @@
  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    138   
    fn deserialize_nonstreaming(
  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(&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   
    }