Server Test

Server Test

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
   34     42   
pub enum Event {

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
   34     42   
pub enum Event {

tmp-codegen-diff/codegen-server-test/ebs/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
///
   34     42   
/// This is a constrained type because its corresponding modeled Smithy shape has one or more

tmp-codegen-diff/codegen-server-test/json_rpc10/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(
   34     42   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
@@ -742,750 +801,820 @@
  762    770   
pub struct ComplexNestedErrorData {
  763    771   
    #[allow(missing_docs)] // documentation missing in model
  764    772   
    pub foo: ::std::option::Option<::std::string::String>,
  765    773   
}
  766    774   
impl ComplexNestedErrorData {
  767    775   
    #[allow(missing_docs)] // documentation missing in model
  768    776   
    pub fn foo(&self) -> ::std::option::Option<&str> {
  769    777   
        self.foo.as_deref()
  770    778   
    }
  771    779   
}
         780  +
impl ::std::fmt::Display for ComplexNestedErrorData {
         781  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         782  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
         783  +
        if let ::std::option::Option::Some(inner) = &self.foo {
         784  +
            ::std::write!(f, "foo=Some({})", inner)?;
         785  +
        } else {
         786  +
            ::std::write!(f, "foo=None")?;
         787  +
        }
         788  +
        ::std::write!(f, "}}")
         789  +
    }
         790  +
}
  772    791   
impl ComplexNestedErrorData {
  773    792   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::model::ComplexNestedErrorData).
  774    793   
    pub fn builder() -> crate::model::complex_nested_error_data::Builder {
  775    794   
        crate::model::complex_nested_error_data::Builder::default()
  776    795   
    }
  777    796   
}
  778    797   
/// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
  779    798   
pub mod validation_exception_field {
  780    799   
  781    800   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]

tmp-codegen-diff/codegen-server-test/json_rpc11/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
/// A union with a representative set of types for members.
   33     41   
#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
   34     42   
pub enum MyUnion {
@@ -308,316 +367,386 @@
  328    336   
pub struct ComplexNestedErrorData {
  329    337   
    #[allow(missing_docs)] // documentation missing in model
  330    338   
    pub foo: ::std::option::Option<::std::string::String>,
  331    339   
}
  332    340   
impl ComplexNestedErrorData {
  333    341   
    #[allow(missing_docs)] // documentation missing in model
  334    342   
    pub fn foo(&self) -> ::std::option::Option<&str> {
  335    343   
        self.foo.as_deref()
  336    344   
    }
  337    345   
}
         346  +
impl ::std::fmt::Display for ComplexNestedErrorData {
         347  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         348  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
         349  +
        if let ::std::option::Option::Some(inner) = &self.foo {
         350  +
            ::std::write!(f, "foo=Some({})", inner)?;
         351  +
        } else {
         352  +
            ::std::write!(f, "foo=None")?;
         353  +
        }
         354  +
        ::std::write!(f, "}}")
         355  +
    }
         356  +
}
  338    357   
impl ComplexNestedErrorData {
  339    358   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::model::ComplexNestedErrorData).
  340    359   
    pub fn builder() -> crate::model::complex_nested_error_data::Builder {
  341    360   
        crate::model::complex_nested_error_data::Builder::default()
  342    361   
    }
  343    362   
}
  344    363   
  345    364   
#[allow(missing_docs)] // documentation missing in model
  346    365   
///
  347    366   
/// This is a constrained type because its corresponding modeled Smithy shape has one or more
@@ -602,621 +724,907 @@
  622    641   
    }
  623    642   
    #[allow(missing_docs)] // documentation missing in model
  624    643   
    pub fn timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
  625    644   
        self.timestamp.as_ref()
  626    645   
    }
  627    646   
    #[allow(missing_docs)] // documentation missing in model
  628    647   
    pub fn unix_timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
  629    648   
        self.unix_timestamp.as_ref()
  630    649   
    }
  631    650   
}
         651  +
impl ::std::fmt::Display for KitchenSink {
         652  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         653  +
        ::std::write!(f, "KitchenSink {{")?;
         654  +
        if let ::std::option::Option::Some(_) = &self.blob {
         655  +
            ::std::write!(f, "blob=Some()")?;
         656  +
        } else {
         657  +
            ::std::write!(f, "blob=None")?;
         658  +
        }
         659  +
        if let ::std::option::Option::Some(inner) = &self.boolean {
         660  +
            ::std::write!(f, ", boolean=Some({})", inner)?;
         661  +
        } else {
         662  +
            ::std::write!(f, ", boolean=None")?;
         663  +
        }
         664  +
        if let ::std::option::Option::Some(inner) = &self.double {
         665  +
            ::std::write!(f, ", double=Some({})", inner)?;
         666  +
        } else {
         667  +
            ::std::write!(f, ", double=None")?;
         668  +
        }
         669  +
        if let ::std::option::Option::Some(inner) = &self.empty_struct {
         670  +
            ::std::write!(f, ", empty_struct=Some({})", inner)?;
         671  +
        } else {
         672  +
            ::std::write!(f, ", empty_struct=None")?;
         673  +
        }
         674  +
        if let ::std::option::Option::Some(inner) = &self.float {
         675  +
            ::std::write!(f, ", float=Some({})", inner)?;
         676  +
        } else {
         677  +
            ::std::write!(f, ", float=None")?;
         678  +
        }
         679  +
        if let ::std::option::Option::Some(inner) = &self.httpdate_timestamp {
         680  +
            ::std::write!(f, ", httpdate_timestamp=Some({})", inner)?;
         681  +
        } else {
         682  +
            ::std::write!(f, ", httpdate_timestamp=None")?;
         683  +
        }
         684  +
        if let ::std::option::Option::Some(inner) = &self.integer {
         685  +
            ::std::write!(f, ", integer=Some({})", inner)?;
         686  +
        } else {
         687  +
            ::std::write!(f, ", integer=None")?;
         688  +
        }
         689  +
        if let ::std::option::Option::Some(inner) = &self.iso8601_timestamp {
         690  +
            ::std::write!(f, ", iso8601_timestamp=Some({})", inner)?;
         691  +
        } else {
         692  +
            ::std::write!(f, ", iso8601_timestamp=None")?;
         693  +
        }
         694  +
        if let ::std::option::Option::Some(inner) = &self.json_value {
         695  +
            ::std::write!(f, ", json_value=Some({})", inner)?;
         696  +
        } else {
         697  +
            ::std::write!(f, ", json_value=None")?;
         698  +
        }
         699  +
        if let ::std::option::Option::Some(_) = &self.list_of_lists {
         700  +
            ::std::write!(f, ", list_of_lists=Some()")?;
         701  +
        } else {
         702  +
            ::std::write!(f, ", list_of_lists=None")?;
         703  +
        }
         704  +
        if let ::std::option::Option::Some(_) = &self.list_of_maps_of_strings {
         705  +
            ::std::write!(f, ", list_of_maps_of_strings=Some()")?;
         706  +
        } else {
         707  +
            ::std::write!(f, ", list_of_maps_of_strings=None")?;
         708  +
        }
         709  +
        if let ::std::option::Option::Some(_) = &self.list_of_strings {
         710  +
            ::std::write!(f, ", list_of_strings=Some()")?;
         711  +
        } else {
         712  +
            ::std::write!(f, ", list_of_strings=None")?;
         713  +
        }
         714  +
        if let ::std::option::Option::Some(_) = &self.list_of_structs {
         715  +
            ::std::write!(f, ", list_of_structs=Some()")?;
         716  +
        } else {
         717  +
            ::std::write!(f, ", list_of_structs=None")?;
         718  +
        }
         719  +
        if let ::std::option::Option::Some(inner) = &self.long {
         720  +
            ::std::write!(f, ", long=Some({})", inner)?;
         721  +
        } else {
         722  +
            ::std::write!(f, ", long=None")?;
         723  +
        }
         724  +
        if let ::std::option::Option::Some(_) = &self.map_of_lists_of_strings {
         725  +
            ::std::write!(f, ", map_of_lists_of_strings=Some()")?;
         726  +
        } else {
         727  +
            ::std::write!(f, ", map_of_lists_of_strings=None")?;
         728  +
        }
         729  +
        if let ::std::option::Option::Some(_) = &self.map_of_maps {
         730  +
            ::std::write!(f, ", map_of_maps=Some()")?;
         731  +
        } else {
         732  +
            ::std::write!(f, ", map_of_maps=None")?;
         733  +
        }
         734  +
        if let ::std::option::Option::Some(_) = &self.map_of_strings {
         735  +
            ::std::write!(f, ", map_of_strings=Some()")?;
         736  +
        } else {
         737  +
            ::std::write!(f, ", map_of_strings=None")?;
         738  +
        }
         739  +
        if let ::std::option::Option::Some(_) = &self.map_of_structs {
         740  +
            ::std::write!(f, ", map_of_structs=Some()")?;
         741  +
        } else {
         742  +
            ::std::write!(f, ", map_of_structs=None")?;
         743  +
        }
         744  +
        if let ::std::option::Option::Some(_) = &self.recursive_list {
         745  +
            ::std::write!(f, ", recursive_list=Some()")?;
         746  +
        } else {
         747  +
            ::std::write!(f, ", recursive_list=None")?;
         748  +
        }
         749  +
        if let ::std::option::Option::Some(_) = &self.recursive_map {
         750  +
            ::std::write!(f, ", recursive_map=Some()")?;
         751  +
        } else {
         752  +
            ::std::write!(f, ", recursive_map=None")?;
         753  +
        }
         754  +
        if let ::std::option::Option::Some(inner) = &self.recursive_struct {
         755  +
            ::std::write!(f, ", recursive_struct=Some({})", inner)?;
         756  +
        } else {
         757  +
            ::std::write!(f, ", recursive_struct=None")?;
         758  +
        }
         759  +
        if let ::std::option::Option::Some(inner) = &self.simple_struct {
         760  +
            ::std::write!(f, ", simple_struct=Some({})", inner)?;
         761  +
        } else {
         762  +
            ::std::write!(f, ", simple_struct=None")?;
         763  +
        }
         764  +
        if let ::std::option::Option::Some(inner) = &self.string {
         765  +
            ::std::write!(f, ", string=Some({})", inner)?;
         766  +
        } else {
         767  +
            ::std::write!(f, ", string=None")?;
         768  +
        }
         769  +
        if let ::std::option::Option::Some(inner) = &self.struct_with_json_name {
         770  +
            ::std::write!(f, ", struct_with_json_name=Some({})", inner)?;
         771  +
        } else {
         772  +
            ::std::write!(f, ", struct_with_json_name=None")?;
         773  +
        }
         774  +
        if let ::std::option::Option::Some(inner) = &self.timestamp {
         775  +
            ::std::write!(f, ", timestamp=Some({})", inner)?;
         776  +
        } else {
         777  +
            ::std::write!(f, ", timestamp=None")?;
         778  +
        }
         779  +
        if let ::std::option::Option::Some(inner) = &self.unix_timestamp {
         780  +
            ::std::write!(f, ", unix_timestamp=Some({})", inner)?;
         781  +
        } else {
         782  +
            ::std::write!(f, ", unix_timestamp=None")?;
         783  +
        }
         784  +
        ::std::write!(f, "}}")
         785  +
    }
         786  +
}
  632    787   
impl KitchenSink {
  633    788   
    /// Creates a new builder-style object to manufacture [`KitchenSink`](crate::model::KitchenSink).
  634    789   
    pub fn builder() -> crate::model::kitchen_sink::Builder {
  635    790   
        crate::model::kitchen_sink::Builder::default()
  636    791   
    }
  637    792   
}
  638    793   
impl crate::constrained::Constrained for crate::model::KitchenSink {
  639    794   
    type Unconstrained = crate::model::kitchen_sink::Builder;
  640    795   
}
  641    796   
  642    797   
#[allow(missing_docs)] // documentation missing in model
  643    798   
#[derive(
  644    799   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  645    800   
)]
  646    801   
pub struct StructWithJsonName {
  647    802   
    #[allow(missing_docs)] // documentation missing in model
  648    803   
    pub value: ::std::option::Option<::std::string::String>,
  649    804   
}
  650    805   
impl StructWithJsonName {
  651    806   
    #[allow(missing_docs)] // documentation missing in model
  652    807   
    pub fn value(&self) -> ::std::option::Option<&str> {
  653    808   
        self.value.as_deref()
  654    809   
    }
  655    810   
}
         811  +
impl ::std::fmt::Display for StructWithJsonName {
         812  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         813  +
        ::std::write!(f, "StructWithJsonName {{")?;
         814  +
        if let ::std::option::Option::Some(inner) = &self.value {
         815  +
            ::std::write!(f, "value=Some({})", inner)?;
         816  +
        } else {
         817  +
            ::std::write!(f, "value=None")?;
         818  +
        }
         819  +
        ::std::write!(f, "}}")
         820  +
    }
         821  +
}
  656    822   
impl StructWithJsonName {
  657    823   
    /// Creates a new builder-style object to manufacture [`StructWithJsonName`](crate::model::StructWithJsonName).
  658    824   
    pub fn builder() -> crate::model::struct_with_json_name::Builder {
  659    825   
        crate::model::struct_with_json_name::Builder::default()
  660    826   
    }
  661    827   
}
  662    828   
impl crate::constrained::Constrained for crate::model::StructWithJsonName {
  663    829   
    type Unconstrained = crate::model::struct_with_json_name::Builder;
  664    830   
}
  665    831   
  666    832   
#[allow(missing_docs)] // documentation missing in model
  667    833   
#[derive(
  668    834   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  669    835   
)]
  670    836   
pub struct SimpleStruct {
  671    837   
    #[allow(missing_docs)] // documentation missing in model
  672    838   
    pub value: ::std::option::Option<::std::string::String>,
  673    839   
}
  674    840   
impl SimpleStruct {
  675    841   
    #[allow(missing_docs)] // documentation missing in model
  676    842   
    pub fn value(&self) -> ::std::option::Option<&str> {
  677    843   
        self.value.as_deref()
  678    844   
    }
  679    845   
}
         846  +
impl ::std::fmt::Display for SimpleStruct {
         847  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         848  +
        ::std::write!(f, "SimpleStruct {{")?;
         849  +
        if let ::std::option::Option::Some(inner) = &self.value {
         850  +
            ::std::write!(f, "value=Some({})", inner)?;
         851  +
        } else {
         852  +
            ::std::write!(f, "value=None")?;
         853  +
        }
         854  +
        ::std::write!(f, "}}")
         855  +
    }
         856  +
}
  680    857   
impl SimpleStruct {
  681    858   
    /// Creates a new builder-style object to manufacture [`SimpleStruct`](crate::model::SimpleStruct).
  682    859   
    pub fn builder() -> crate::model::simple_struct::Builder {
  683    860   
        crate::model::simple_struct::Builder::default()
  684    861   
    }
  685    862   
}
  686    863   
impl crate::constrained::Constrained for crate::model::SimpleStruct {
  687    864   
    type Unconstrained = crate::model::simple_struct::Builder;
  688    865   
}
  689    866   
  690    867   
#[allow(missing_docs)] // documentation missing in model
  691    868   
#[derive(
  692    869   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  693    870   
)]
  694    871   
pub struct EmptyStruct {}
         872  +
impl ::std::fmt::Display for EmptyStruct {
         873  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         874  +
        ::std::write!(f, "EmptyStruct {{")?;
         875  +
        ::std::write!(f, "}}")
         876  +
    }
         877  +
}
  695    878   
impl EmptyStruct {
  696    879   
    /// Creates a new builder-style object to manufacture [`EmptyStruct`](crate::model::EmptyStruct).
  697    880   
    pub fn builder() -> crate::model::empty_struct::Builder {
  698    881   
        crate::model::empty_struct::Builder::default()
  699    882   
    }
  700    883   
}
  701    884   
impl crate::constrained::Constrained for crate::model::EmptyStruct {
  702    885   
    type Unconstrained = crate::model::empty_struct::Builder;
  703    886   
}
  704    887   
/// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).

tmp-codegen-diff/codegen-server-test/misc/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
///
   34     42   
/// This is a constrained type because its corresponding modeled Smithy shape has one or more

tmp-codegen-diff/codegen-server-test/naming_test_ops/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
///
   33     41   
/// _Note: `UnknownVariantCollidingEnum::Self` has been renamed to `::SelfValue`.
   34     42   
/// `UnknownVariantCollidingEnum::SelfValue` has been renamed to `::SelfValue_`._

tmp-codegen-diff/codegen-server-test/pokemon-service-awsjson-server-sdk/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
   34     42   
pub enum CapturePokemonEvents {

tmp-codegen-diff/codegen-server-test/pokemon-service-server-sdk/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(
   34     42   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(
   34     42   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
@@ -1275,1283 +1334,1353 @@
 1295   1303   
pub struct ComplexNestedErrorData {
 1296   1304   
    #[allow(missing_docs)] // documentation missing in model
 1297   1305   
    pub foo: ::std::option::Option<::std::string::String>,
 1298   1306   
}
 1299   1307   
impl ComplexNestedErrorData {
 1300   1308   
    #[allow(missing_docs)] // documentation missing in model
 1301   1309   
    pub fn foo(&self) -> ::std::option::Option<&str> {
 1302   1310   
        self.foo.as_deref()
 1303   1311   
    }
 1304   1312   
}
        1313  +
impl ::std::fmt::Display for ComplexNestedErrorData {
        1314  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        1315  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
        1316  +
        if let ::std::option::Option::Some(inner) = &self.foo {
        1317  +
            ::std::write!(f, "foo=Some({})", inner)?;
        1318  +
        } else {
        1319  +
            ::std::write!(f, "foo=None")?;
        1320  +
        }
        1321  +
        ::std::write!(f, "}}")
        1322  +
    }
        1323  +
}
 1305   1324   
impl ComplexNestedErrorData {
 1306   1325   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::model::ComplexNestedErrorData).
 1307   1326   
    pub fn builder() -> crate::model::complex_nested_error_data::Builder {
 1308   1327   
        crate::model::complex_nested_error_data::Builder::default()
 1309   1328   
    }
 1310   1329   
}
 1311   1330   
 1312   1331   
#[allow(missing_docs)] // documentation missing in model
 1313   1332   
#[derive(
 1314   1333   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/model.rs

@@ -31,31 +90,98 @@
   51     51   
    pub fn path(&self) -> &str {
   52     52   
        use std::ops::Deref;
   53     53   
        self.path.deref()
   54     54   
    }
   55     55   
    /// A detailed description of the validation failure.
   56     56   
    pub fn message(&self) -> &str {
   57     57   
        use std::ops::Deref;
   58     58   
        self.message.deref()
   59     59   
    }
   60     60   
}
          61  +
impl ::std::fmt::Display for ValidationExceptionField {
          62  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          63  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          64  +
        ::std::write!(f, "path={}", &self.path)?;
          65  +
        ::std::write!(f, ", message={}", &self.message)?;
          66  +
        ::std::write!(f, "}}")
          67  +
    }
          68  +
}
   61     69   
impl ValidationExceptionField {
   62     70   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   63     71   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   64     72   
        crate::model::validation_exception_field::Builder::default()
   65     73   
    }
   66     74   
}
   67     75   
   68     76   
#[allow(missing_docs)] // documentation missing in model
   69     77   
#[derive(
   70     78   
    ::std::clone::Clone,

tmp-codegen-diff/codegen-server-test/rest_json_validation/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
///
   34     42   
/// This is a constrained type because its corresponding modeled Smithy shape has one or more

tmp-codegen-diff/codegen-server-test/rpcv2Cbor/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(
   34     42   
    ::std::clone::Clone,
@@ -306,314 +365,384 @@
  326    334   
pub struct ComplexNestedErrorData {
  327    335   
    #[allow(missing_docs)] // documentation missing in model
  328    336   
    pub foo: ::std::option::Option<::std::string::String>,
  329    337   
}
  330    338   
impl ComplexNestedErrorData {
  331    339   
    #[allow(missing_docs)] // documentation missing in model
  332    340   
    pub fn foo(&self) -> ::std::option::Option<&str> {
  333    341   
        self.foo.as_deref()
  334    342   
    }
  335    343   
}
         344  +
impl ::std::fmt::Display for ComplexNestedErrorData {
         345  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         346  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
         347  +
        if let ::std::option::Option::Some(inner) = &self.foo {
         348  +
            ::std::write!(f, "foo=Some({})", inner)?;
         349  +
        } else {
         350  +
            ::std::write!(f, "foo=None")?;
         351  +
        }
         352  +
        ::std::write!(f, "}}")
         353  +
    }
         354  +
}
  336    355   
impl ComplexNestedErrorData {
  337    356   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::model::ComplexNestedErrorData).
  338    357   
    pub fn builder() -> crate::model::complex_nested_error_data::Builder {
  339    358   
        crate::model::complex_nested_error_data::Builder::default()
  340    359   
    }
  341    360   
}
  342    361   
  343    362   
#[allow(missing_docs)] // documentation missing in model
  344    363   
#[derive(
  345    364   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
   34     42   
pub enum ComplexUnion {

tmp-codegen-diff/codegen-server-test/s3/rust-server-codegen/src/model.rs

@@ -1,1 +54,62 @@
   15     15   
    pub fn path(&self) -> &str {
   16     16   
        use std::ops::Deref;
   17     17   
        self.path.deref()
   18     18   
    }
   19     19   
    /// A detailed description of the validation failure.
   20     20   
    pub fn message(&self) -> &str {
   21     21   
        use std::ops::Deref;
   22     22   
        self.message.deref()
   23     23   
    }
   24     24   
}
          25  +
impl ::std::fmt::Display for ValidationExceptionField {
          26  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          27  +
        ::std::write!(f, "ValidationExceptionField {{")?;
          28  +
        ::std::write!(f, "path={}", &self.path)?;
          29  +
        ::std::write!(f, ", message={}", &self.message)?;
          30  +
        ::std::write!(f, "}}")
          31  +
    }
          32  +
}
   25     33   
impl ValidationExceptionField {
   26     34   
    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
   27     35   
    pub fn builder() -> crate::model::validation_exception_field::Builder {
   28     36   
        crate::model::validation_exception_field::Builder::default()
   29     37   
    }
   30     38   
}
   31     39   
   32     40   
#[allow(missing_docs)] // documentation missing in model
   33     41   
///
   34     42   
/// This is a constrained type because its corresponding modeled Smithy shape has one or more