Client Test

Client Test

rev. 163d4d6410694aaf071424777ecbecd050925f36

Files changed:

tmp-codegen-diff/codegen-client-test/rest_json/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_json/rust-client-codegen/src/types/_structure_payload_event.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.payload {
   47     47   
            ser.write_struct(&STRUCTUREPAYLOADEVENT_MEMBER_PAYLOAD, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl StructurePayloadEvent {
   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(&STRUCTUREPAYLOADEVENT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&STRUCTUREPAYLOADEVENT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.payload = Some(crate::types::PayloadStructure::deserialize(deser)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl StructurePayloadEvent {
          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 StructurePayloadEvent {
   79     90   
    /// Creates a new builder-style object to manufacture [`StructurePayloadEvent`](crate::types::StructurePayloadEvent).
   80     91   
    pub fn builder() -> crate::types::builders::StructurePayloadEventBuilder {
   81     92   
        crate::types::builders::StructurePayloadEventBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`StructurePayloadEvent`](crate::types::StructurePayloadEvent).
   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_json/rust-client-codegen/src/types/_test_config.rs

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

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

@@ -9,9 +180,185 @@
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restjson#TopLevel", "aws.protocoltests.restjson", "TopLevel");
   30     30   
static TOPLEVEL_MEMBER_DIALOG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restjson#TopLevel$dialog", "aws.protocoltests.restjson", "TopLevel"),
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    "dialog",
   34     34   
    0,
   35     35   
);
   36     36   
static TOPLEVEL_MEMBER_DIALOG_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restjson#TopLevel$dialogList", "aws.protocoltests.restjson", "TopLevel"),
   38     38   
    ::aws_smithy_schema::ShapeType::List,
   39         -
    "dialog_list",
          39  +
    "dialogList",
   40     40   
    1,
   41     41   
);
   42     42   
static TOPLEVEL_MEMBER_DIALOG_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("aws.protocoltests.restjson#TopLevel$dialogMap", "aws.protocoltests.restjson", "TopLevel"),
   44     44   
    ::aws_smithy_schema::ShapeType::Map,
   45         -
    "dialog_map",
          45  +
    "dialogMap",
   46     46   
    2,
   47     47   
);
   48     48   
static TOPLEVEL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    TOPLEVEL_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&TOPLEVEL_MEMBER_DIALOG, &TOPLEVEL_MEMBER_DIALOG_LIST, &TOPLEVEL_MEMBER_DIALOG_MAP],
   52     52   
);
   53     53   
impl TopLevel {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TOPLEVEL_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for TopLevel {
   58     58   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     59   
    fn serialize_members(
   60     60   
        &self,
   61     61   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     62   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     63   
        {
   64     64   
            let val = &self.dialog;
   65     65   
            ser.write_struct(&TOPLEVEL_MEMBER_DIALOG, val)?;
   66     66   
        }
   67     67   
        {
   68     68   
            let val = &self.dialog_list;
   69     69   
   70     70   
            ser.write_list(
   71     71   
                &TOPLEVEL_MEMBER_DIALOG_LIST,
   72     72   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     73   
                    for item in val {
   74     74   
                        ser.write_struct(crate::types::Dialog::SCHEMA, item)?;
   75     75   
                    }
   76     76   
                    Ok(())
   77     77   
                },
   78     78   
            )?;
   79     79   
        }
   80     80   
        {
   81     81   
            let val = &self.dialog_map;
   82     82   
   83     83   
            ser.write_map(
   84     84   
                &TOPLEVEL_MEMBER_DIALOG_MAP,
   85     85   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   86     86   
                    for (key, value) in val {
   87     87   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   88     88   
                        ser.write_struct(crate::types::Dialog::SCHEMA, value)?;
   89     89   
                    }
   90     90   
                    Ok(())
   91     91   
                },
   92     92   
            )?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl TopLevel {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&TOPLEVEL_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&TOPLEVEL_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.dialog = Some(crate::types::Dialog::deserialize(deser)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.dialog_list = Some({
  118         -
                        let container = if let Some(cap) = deser.container_size() {
  119         -
                            Vec::with_capacity(cap)
  120         -
                        } else {
  121         -
                            Vec::new()
  122         -
                        };
  123         -
                        deser.read_list(member, container, |mut list, deser| {
  124         -
                            list.push(crate::types::Dialog::deserialize(deser)?);
  125         -
                            Ok(list)
  126         -
                        })?
         118  +
                        let mut container = Vec::new();
         119  +
                        deser.read_list(member, &mut |deser| {
         120  +
                            container.push(crate::types::Dialog::deserialize(deser)?);
         121  +
                            Ok(())
         122  +
                        })?;
         123  +
                        container
  127    124   
                    });
  128    125   
                }
  129    126   
                Some(2) => {
  130    127   
                    builder.dialog_map = Some({
  131         -
                        let container = if let Some(cap) = deser.container_size() {
  132         -
                            std::collections::HashMap::with_capacity(cap)
  133         -
                        } else {
  134         -
                            std::collections::HashMap::new()
  135         -
                        };
  136         -
                        deser.read_map(member, container, |mut map, key, deser| {
  137         -
                            map.insert(key, crate::types::Dialog::deserialize(deser)?);
  138         -
                            Ok(map)
  139         -
                        })?
         128  +
                        let mut container = std::collections::HashMap::new();
         129  +
                        deser.read_map(member, &mut |key, deser| {
         130  +
                            container.insert(key, crate::types::Dialog::deserialize(deser)?);
         131  +
                            Ok(())
         132  +
                        })?;
         133  +
                        container
  140    134   
                    });
  141    135   
                }
  142    136   
                _ => {}
  143    137   
            }
  144    138   
            Ok(())
  145    139   
        })?;
  146    140   
        builder
  147    141   
            .build()
  148    142   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  149    143   
    }
  150    144   
}
         145  +
impl TopLevel {
         146  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         147  +
    pub fn deserialize_with_response(
         148  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         149  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         150  +
        _status: u16,
         151  +
        _body: &[u8],
         152  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         153  +
        Self::deserialize(deserializer)
         154  +
    }
         155  +
}
  151    156   
impl TopLevel {
  152    157   
    /// Creates a new builder-style object to manufacture [`TopLevel`](crate::types::TopLevel).
  153    158   
    pub fn builder() -> crate::types::builders::TopLevelBuilder {
  154    159   
        crate::types::builders::TopLevelBuilder::default()
  155    160   
    }
  156    161   
}
  157    162   
  158    163   
/// A builder for [`TopLevel`](crate::types::TopLevel).
  159    164   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  160    165   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_json/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.restjson#UnionPayload", "aws.protocoltests.restjson", "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.restjson#UnionPayload$greeting",
          43  +
        "aws.protocoltests.restjson",
          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_json/rust-client-codegen/src/types/_union_payload_event.rs

@@ -17,17 +110,118 @@
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNIONPAYLOADEVENT_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for UnionPayloadEvent {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   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.payload {
   47         -
            ser.write_null(&UNIONPAYLOADEVENT_MEMBER_PAYLOAD)?;
          47  +
            ser.write_struct(&UNIONPAYLOADEVENT_MEMBER_PAYLOAD, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl UnionPayloadEvent {
   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(&UNIONPAYLOADEVENT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&UNIONPAYLOADEVENT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69         -
                    builder.payload = Some({
   70         -
                        let _ = member;
   71         -
                        todo!("deserialize aggregate")
   72         -
                    });
          69  +
                    builder.payload = Some(crate::types::PayloadUnion::deserialize(deser)?);
   73     70   
                }
   74     71   
                _ => {}
   75     72   
            }
   76     73   
            Ok(())
   77     74   
        })?;
   78     75   
        Ok(builder.build())
   79     76   
    }
   80     77   
}
          78  +
impl UnionPayloadEvent {
          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  +
}
   81     89   
impl UnionPayloadEvent {
   82     90   
    /// Creates a new builder-style object to manufacture [`UnionPayloadEvent`](crate::types::UnionPayloadEvent).
   83     91   
    pub fn builder() -> crate::types::builders::UnionPayloadEventBuilder {
   84     92   
        crate::types::builders::UnionPayloadEventBuilder::default()
   85     93   
    }
   86     94   
}
   87     95   
   88     96   
/// A builder for [`UnionPayloadEvent`](crate::types::UnionPayloadEvent).
   89     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   90     98   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/types/_union_with_json_name.rs

@@ -37,37 +0,156 @@
   57     57   
    }
   58     58   
    /// Returns true if this is a [`Foo`](crate::types::UnionWithJsonName::Foo).
   59     59   
    pub fn is_foo(&self) -> bool {
   60     60   
        self.as_foo().is_ok()
   61     61   
    }
   62     62   
    /// Returns true if the enum instance is the `Unknown` variant.
   63     63   
    pub fn is_unknown(&self) -> bool {
   64     64   
        matches!(self, Self::Unknown)
   65     65   
    }
   66     66   
}
          67  +
static UNIONWITHJSONNAME_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          68  +
    "aws.protocoltests.restjson#UnionWithJsonName",
          69  +
    "aws.protocoltests.restjson",
          70  +
    "UnionWithJsonName",
          71  +
);
          72  +
static UNIONWITHJSONNAME_MEMBER_FOO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          73  +
    ::aws_smithy_schema::ShapeId::from_static(
          74  +
        "aws.protocoltests.restjson#UnionWithJsonName$foo",
          75  +
        "aws.protocoltests.restjson",
          76  +
        "UnionWithJsonName",
          77  +
    ),
          78  +
    ::aws_smithy_schema::ShapeType::String,
          79  +
    "foo",
          80  +
    0,
          81  +
)
          82  +
.with_json_name("FOO");
          83  +
static UNIONWITHJSONNAME_MEMBER_BAR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          84  +
    ::aws_smithy_schema::ShapeId::from_static(
          85  +
        "aws.protocoltests.restjson#UnionWithJsonName$bar",
          86  +
        "aws.protocoltests.restjson",
          87  +
        "UnionWithJsonName",
          88  +
    ),
          89  +
    ::aws_smithy_schema::ShapeType::String,
          90  +
    "bar",
          91  +
    1,
          92  +
);
          93  +
static UNIONWITHJSONNAME_MEMBER_BAZ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          94  +
    ::aws_smithy_schema::ShapeId::from_static(
          95  +
        "aws.protocoltests.restjson#UnionWithJsonName$baz",
          96  +
        "aws.protocoltests.restjson",
          97  +
        "UnionWithJsonName",
          98  +
    ),
          99  +
    ::aws_smithy_schema::ShapeType::String,
         100  +
    "baz",
         101  +
    2,
         102  +
)
         103  +
.with_json_name("_baz");
         104  +
static UNIONWITHJSONNAME_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         105  +
    UNIONWITHJSONNAME_SCHEMA_ID,
         106  +
    ::aws_smithy_schema::ShapeType::Union,
         107  +
    &[
         108  +
        &UNIONWITHJSONNAME_MEMBER_FOO,
         109  +
        &UNIONWITHJSONNAME_MEMBER_BAR,
         110  +
        &UNIONWITHJSONNAME_MEMBER_BAZ,
         111  +
    ],
         112  +
);
         113  +
impl UnionWithJsonName {
         114  +
    /// The schema for this shape.
         115  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNIONWITHJSONNAME_SCHEMA;
         116  +
}
         117  +
impl ::aws_smithy_schema::serde::SerializableStruct for UnionWithJsonName {
         118  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         119  +
    fn serialize_members(
         120  +
        &self,
         121  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         122  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         123  +
        match self {
         124  +
            Self::Foo(val) => {
         125  +
                ser.write_string(&UNIONWITHJSONNAME_MEMBER_FOO, val)?;
         126  +
            }
         127  +
            Self::Bar(val) => {
         128  +
                ser.write_string(&UNIONWITHJSONNAME_MEMBER_BAR, val)?;
         129  +
            }
         130  +
            Self::Baz(val) => {
         131  +
                ser.write_string(&UNIONWITHJSONNAME_MEMBER_BAZ, val)?;
         132  +
            }
         133  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         134  +
        }
         135  +
        Ok(())
         136  +
    }
         137  +
}
         138  +
impl UnionWithJsonName {
         139  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         140  +
    pub fn deserialize(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         142  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         143  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         144  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         145  +
        deserializer.read_struct(&UNIONWITHJSONNAME_SCHEMA, &mut |member, deser| {
         146  +
            result = ::std::option::Option::Some(match member.member_index() {
         147  +
                Some(0) => Self::Foo(deser.read_string(member)?),
         148  +
                Some(1) => Self::Bar(deser.read_string(member)?),
         149  +
                Some(2) => Self::Baz(deser.read_string(member)?),
         150  +
                _ => Self::Unknown,
         151  +
            });
         152  +
            Ok(())
         153  +
        })?;
         154  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         155  +
    }
         156  +
}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/types/_unit.rs

@@ -1,1 +61,72 @@
   14     14   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   15     15   
    fn serialize_members(
   16     16   
        &self,
   17     17   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   18     18   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   19     19   
        Ok(())
   20     20   
    }
   21     21   
}
   22     22   
impl Unit {
   23     23   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   24         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   25         -
        deserializer: &mut D,
          24  +
    pub fn deserialize(
          25  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   26     26   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   27     27   
        #[allow(unused_variables, unused_mut)]
   28     28   
        let mut builder = Self::builder();
   29     29   
        #[allow(
   30     30   
            unused_variables,
   31     31   
            unreachable_code,
   32     32   
            clippy::single_match,
   33     33   
            clippy::match_single_binding,
   34     34   
            clippy::diverging_sub_expression
   35     35   
        )]
   36         -
        deserializer.read_struct(&UNIT_SCHEMA, (), |_, member, deser| {
          36  +
        deserializer.read_struct(&UNIT_SCHEMA, &mut |member, deser| {
   37     37   
            match member.member_index() {
   38     38   
                _ => {}
   39     39   
            }
   40     40   
            Ok(())
   41     41   
        })?;
   42     42   
        Ok(builder.build())
   43     43   
    }
   44     44   
}
          45  +
impl Unit {
          46  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          47  +
    pub fn deserialize_with_response(
          48  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          49  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          50  +
        _status: u16,
          51  +
        _body: &[u8],
          52  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          53  +
        Ok(Self::builder().build())
          54  +
    }
          55  +
}
   45     56   
impl Unit {
   46     57   
    /// Creates a new builder-style object to manufacture [`Unit`](crate::types::Unit).
   47     58   
    pub fn builder() -> crate::types::builders::UnitBuilder {
   48     59   
        crate::types::builders::UnitBuilder::default()
   49     60   
    }
   50     61   
}
   51     62   
   52     63   
/// A builder for [`Unit`](crate::types::Unit).
   53     64   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   54     65   
#[non_exhaustive]

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

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

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/types/error/_error_event.rs

@@ -15,15 +98,109 @@
   35     35   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   36     36   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   37     37   
        if let Some(ref val) = self.message {
   38     38   
            ser.write_string(&ERROREVENT_MEMBER_MESSAGE, val)?;
   39     39   
        }
   40     40   
        Ok(())
   41     41   
    }
   42     42   
}
   43     43   
impl ErrorEvent {
   44     44   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   45         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   46         -
        deserializer: &mut D,
          45  +
    pub fn deserialize(
          46  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   47     47   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   48     48   
        #[allow(unused_variables, unused_mut)]
   49     49   
        let mut builder = Self::builder();
   50     50   
        #[allow(
   51     51   
            unused_variables,
   52     52   
            unreachable_code,
   53     53   
            clippy::single_match,
   54     54   
            clippy::match_single_binding,
   55     55   
            clippy::diverging_sub_expression
   56     56   
        )]
   57         -
        deserializer.read_struct(&ERROREVENT_SCHEMA, (), |_, member, deser| {
          57  +
        deserializer.read_struct(&ERROREVENT_SCHEMA, &mut |member, deser| {
   58     58   
            match member.member_index() {
   59     59   
                Some(0) => {
   60     60   
                    builder.message = Some(deser.read_string(member)?);
   61     61   
                }
   62     62   
                _ => {}
   63     63   
            }
   64     64   
            Ok(())
   65     65   
        })?;
   66     66   
        Ok(builder.build())
   67     67   
    }
   68     68   
}
          69  +
impl ErrorEvent {
          70  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          71  +
    pub fn deserialize_with_response(
          72  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          73  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          74  +
        _status: u16,
          75  +
        _body: &[u8],
          76  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          77  +
        Self::deserialize(deserializer)
          78  +
    }
          79  +
}
   69     80   
impl ErrorEvent {
   70     81   
    /// Returns the error message.
   71     82   
    pub fn message(&self) -> ::std::option::Option<&str> {
   72     83   
        self.message.as_deref()
   73     84   
    }
   74     85   
}
   75     86   
impl ::std::fmt::Display for ErrorEvent {
   76     87   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   77     88   
        ::std::write!(f, "ErrorEvent")?;
   78     89   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

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

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

@@ -1,1 +102,113 @@
   13     13   
    "aws.protocoltests.restjson",
   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.restjson#InvalidGreeting$Message",
   19     19   
        "aws.protocoltests.restjson",
   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_json/rust-client-codegen/src/types/error/_service_unavailable_error.rs

@@ -18,18 +101,112 @@
   38     38   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   39     39   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   40     40   
        if let Some(ref val) = self.message {
   41     41   
            ser.write_string(&SERVICEUNAVAILABLEERROR_MEMBER_MESSAGE, val)?;
   42     42   
        }
   43     43   
        Ok(())
   44     44   
    }
   45     45   
}
   46     46   
impl ServiceUnavailableError {
   47     47   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   48         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   49         -
        deserializer: &mut D,
          48  +
    pub fn deserialize(
          49  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   50     50   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        #[allow(unused_variables, unused_mut)]
   52     52   
        let mut builder = Self::builder();
   53     53   
        #[allow(
   54     54   
            unused_variables,
   55     55   
            unreachable_code,
   56     56   
            clippy::single_match,
   57     57   
            clippy::match_single_binding,
   58     58   
            clippy::diverging_sub_expression
   59     59   
        )]
   60         -
        deserializer.read_struct(&SERVICEUNAVAILABLEERROR_SCHEMA, (), |_, member, deser| {
          60  +
        deserializer.read_struct(&SERVICEUNAVAILABLEERROR_SCHEMA, &mut |member, deser| {
   61     61   
            match member.member_index() {
   62     62   
                Some(0) => {
   63     63   
                    builder.message = Some(deser.read_string(member)?);
   64     64   
                }
   65     65   
                _ => {}
   66     66   
            }
   67     67   
            Ok(())
   68     68   
        })?;
   69     69   
        Ok(builder.build())
   70     70   
    }
   71     71   
}
          72  +
impl ServiceUnavailableError {
          73  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          74  +
    pub fn deserialize_with_response(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          76  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          77  +
        _status: u16,
          78  +
        _body: &[u8],
          79  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          80  +
        Self::deserialize(deserializer)
          81  +
    }
          82  +
}
   72     83   
impl ServiceUnavailableError {
   73     84   
    /// Returns the error message.
   74     85   
    pub fn message(&self) -> ::std::option::Option<&str> {
   75     86   
        self.message.as_deref()
   76     87   
    }
   77     88   
}
   78     89   
impl ::std::fmt::Display for ServiceUnavailableError {
   79     90   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   80     91   
        ::std::write!(f, "ServiceUnavailableError")?;
   81     92   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +45,43 @@
    4      4   
version = "0.0.1"
    5      5   
authors = ["protocoltest@example.com"]
    6      6   
description = "test"
    7      7   
edition = "2021"
    8      8   
    9      9   
[package.metadata.smithy]
   10     10   
codegen-version = "ci"
   11     11   
protocol = "aws.protocols#restJson1"
   12     12   
[dependencies.aws-smithy-async]
   13     13   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
   14         -
[dependencies.aws-smithy-http]
   15         -
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
   16     14   
[dependencies.aws-smithy-json]
   17     15   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
   18     16   
[dependencies.aws-smithy-runtime]
   19     17   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
   20     18   
features = ["client"]
   21     19   
[dependencies.aws-smithy-runtime-api]
   22     20   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
   23     21   
features = ["client", "http-1x"]
   24     22   
[dependencies.aws-smithy-schema]
   25     23   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-schema"

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

@@ -10,10 +69,73 @@
   30     30   
            config: self.cloneable.clone(),
   31     31   
            runtime_components: self.runtime_components.clone(),
   32     32   
            runtime_plugins: self.runtime_plugins.clone(),
   33     33   
            behavior_version: self.behavior_version,
   34     34   
        }
   35     35   
    }
   36     36   
    /// Return a reference to the stalled stream protection configuration contained in this config, if any.
   37     37   
    pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
   38     38   
        self.config.load::<crate::config::StalledStreamProtectionConfig>()
   39     39   
    }
          40  +
    /// Returns the client protocol used for serialization and deserialization.
          41  +
    pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
          42  +
        self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
          43  +
    }
   40     44   
    /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
   41     45   
    pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
   42     46   
        self.runtime_components.http_client()
   43     47   
    }
   44     48   
    /// Return the auth schemes configured on this service config
   45     49   
    pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
   46     50   
        self.runtime_components.auth_schemes()
   47     51   
    }
   48     52   
   49     53   
    /// Return the auth scheme resolver configured on this service config
@@ -105,109 +185,208 @@
  125    129   
    ///
  126    130   
    pub fn new() -> Self {
  127    131   
        Self::default()
  128    132   
    }
  129    133   
    /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
  130    134   
    /// but not those in runtime components.
  131    135   
    #[allow(unused)]
  132    136   
    pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
  133    137   
        let mut builder = Self::new();
  134    138   
        builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         139  +
        if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
         140  +
            builder.set_protocol(::std::option::Option::Some(protocol));
         141  +
        }
  135    142   
        builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
  136    143   
        builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
  137    144   
        builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
  138    145   
        builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
  139    146   
        builder
  140    147   
    }
  141    148   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  142    149   
    /// to configure protection for stalled streams.
  143    150   
    pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
  144    151   
        self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
  145    152   
        self
  146    153   
    }
  147    154   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  148    155   
    /// to configure protection for stalled streams.
  149    156   
    pub fn set_stalled_stream_protection(
  150    157   
        &mut self,
  151    158   
        stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
  152    159   
    ) -> &mut Self {
  153    160   
        self.config.store_or_unset(stalled_stream_protection_config);
  154    161   
        self
  155    162   
    }
         163  +
    /// Sets the client protocol to use for serialization and deserialization.
         164  +
    ///
         165  +
    /// This overrides the default protocol determined by the service model,
         166  +
    /// enabling runtime protocol selection.
         167  +
    pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         168  +
        self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
         169  +
            protocol,
         170  +
        )));
         171  +
        self
         172  +
    }
         173  +
         174  +
    /// Sets the client protocol to use for serialization and deserialization.
         175  +
    pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         176  +
        self.config.store_or_unset(protocol);
         177  +
        self
         178  +
    }
  156    179   
    /// Sets the HTTP client to use when making requests.
  157    180   
    ///
  158    181   
    /// # Examples
  159    182   
    /// ```no_run
  160    183   
    /// # #[cfg(test)]
  161    184   
    /// # mod tests {
  162    185   
    /// # #[test]
  163    186   
    /// # fn example() {
  164    187   
    /// use std::time::Duration;
  165    188   
    /// use rest_json_extras::config::Config;
@@ -1116,1139 +1175,1203 @@
 1136   1159   
#[derive(::std::fmt::Debug)]
 1137   1160   
pub(crate) struct ServiceRuntimePlugin {
 1138   1161   
    config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
 1139   1162   
    runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1140   1163   
}
 1141   1164   
 1142   1165   
impl ServiceRuntimePlugin {
 1143   1166   
    pub fn new(_service_config: crate::config::Config) -> Self {
 1144   1167   
        let config = {
 1145   1168   
            let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RestJsonExtras");
        1169  +
            if _service_config.protocol().is_none() {
        1170  +
                cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
        1171  +
                    ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
        1172  +
                ));
        1173  +
            }
 1146   1174   
            cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
 1147   1175   
            ::std::option::Option::Some(cfg.freeze())
 1148   1176   
        };
 1149   1177   
        let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
 1150   1178   
        runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
 1151   1179   
            use crate::config::auth::ResolveAuthScheme;
 1152   1180   
            crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
 1153   1181   
        }));
 1154   1182   
        runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
 1155   1183   
        runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());

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

@@ -97,97 +133,129 @@
  117    117   
/// Data structures used by operation inputs/outputs.
  118    118   
pub mod types;
  119    119   
  120    120   
/// All operations that this crate can perform.
  121    121   
pub mod operation;
  122    122   
  123    123   
pub(crate) mod protocol_serde;
  124    124   
  125    125   
mod sdk_feature_tracker;
  126    126   
  127         -
mod serialization_settings;
  128         -
  129         -
mod serde_util;
  130         -
  131    127   
mod json_errors;
  132    128   
  133    129   
pub use client::Client;