Server Test

Server Test

rev. 9815deb0e78f27fa2930fdd2a243ed5e08ec6a8f

Files changed:

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_integer_list.rs

@@ -1,1 +77,75 @@
    8      8   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    9      9   
>
   10     10   
where
   11     11   
    I: Iterator<
   12     12   
        Item = Result<
   13     13   
            ::aws_smithy_json::deserialize::Token<'a>,
   14     14   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   15     15   
        >,
   16     16   
    >,
   17     17   
{
   18         -
    /* JsonParserGenerator.kt:749 */
          18  +
    /* JsonParserGenerator.kt:731 */
   19     19   
    match tokens.next().transpose()? {
   20         -
        /* JsonParserGenerator.kt:750 */
          20  +
        /* JsonParserGenerator.kt:732 */
   21     21   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
   22     22   
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
   23     23   
            /* JsonParserGenerator.kt:444 */
   24     24   
            let mut items = Vec::new();
   25     25   
            /* JsonParserGenerator.kt:445 */
   26     26   
            loop {
   27     27   
                /* JsonParserGenerator.kt:446 */
   28     28   
                match tokens.peek() {
   29     29   
                    /* JsonParserGenerator.kt:447 */
   30     30   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
   31     31   
                        /* JsonParserGenerator.kt:448 */
   32     32   
                        tokens.next().transpose().unwrap();
   33     33   
                        break;
   34     34   
                        /* JsonParserGenerator.kt:447 */
   35     35   
                    }
   36     36   
                    /* JsonParserGenerator.kt:450 */
   37     37   
                    _ => {
   38     38   
                        /* JsonParserGenerator.kt:456 */
   39     39   
                        let value =
   40     40   
                            /* JsonParserGenerator.kt:372 */::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
   41     41   
                                                .map(i32::try_from)
   42     42   
                                                .transpose()?
   43     43   
                        /* JsonParserGenerator.kt:456 */;
   44     44   
                        /* JsonParserGenerator.kt:459 */
   45     45   
                        if let Some(value) = value {
   46     46   
                            items.push(value);
   47         -
                        }
   48         -
                        /* JsonParserGenerator.kt:467 */
   49         -
                        else {
          47  +
                        } else {
   50     48   
                            return Err(
   51     49   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   52     50   
                                    "dense list cannot contain null values",
   53     51   
                                ),
   54     52   
                            );
   55     53   
                        }
   56     54   
                        /* JsonParserGenerator.kt:450 */
   57     55   
                    } /* JsonParserGenerator.kt:446 */
   58     56   
                }
   59     57   
                /* JsonParserGenerator.kt:445 */
   60     58   
            }
   61         -
            /* JsonParserGenerator.kt:483 */
          59  +
            /* JsonParserGenerator.kt:476 */
   62     60   
            Ok(Some(items))
   63         -
            /* JsonParserGenerator.kt:750 */
          61  +
            /* JsonParserGenerator.kt:732 */
   64     62   
        }
   65         -
        /* JsonParserGenerator.kt:759 */
          63  +
        /* JsonParserGenerator.kt:741 */
   66     64   
        _ => {
   67         -
            /* JsonParserGenerator.kt:760 */
          65  +
            /* JsonParserGenerator.kt:742 */
   68     66   
            Err(
   69     67   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   70     68   
                    "expected start array or null",
   71     69   
                ),
   72     70   
            )
   73         -
            /* JsonParserGenerator.kt:759 */
   74         -
        } /* JsonParserGenerator.kt:749 */
          71  +
            /* JsonParserGenerator.kt:741 */
          72  +
        } /* JsonParserGenerator.kt:731 */
   75     73   
    }
   76     74   
    /* JsonParserGenerator.kt:435 */
   77     75   
}

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_blobs.rs

@@ -77,77 +156,156 @@
   97     97   
    crate::input::json_blobs_input::Builder,
   98     98   
    ::aws_smithy_json::deserialize::error::DeserializeError,
   99     99   
> {
  100    100   
    /* JsonParserGenerator.kt:158 */
  101    101   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  102    102   
        crate::protocol_serde::or_empty_doc(_value),
  103    103   
    )
  104    104   
    .peekable();
  105    105   
    let tokens = &mut tokens_owned;
  106    106   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  107         -
    /* JsonParserGenerator.kt:721 */
         107  +
    /* JsonParserGenerator.kt:703 */
  108    108   
    loop {
  109         -
        /* JsonParserGenerator.kt:722 */
         109  +
        /* JsonParserGenerator.kt:704 */
  110    110   
        match tokens.next().transpose()? {
  111         -
            /* JsonParserGenerator.kt:723 */
         111  +
            /* JsonParserGenerator.kt:705 */
  112    112   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  113    113   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  114    114   
                /* JsonParserGenerator.kt:265 */
  115    115   
                match key.to_unescaped()?.as_ref() {
  116    116   
                    /* JsonParserGenerator.kt:267 */
  117    117   
                    "data" => {
  118    118   
                        /* JsonParserGenerator.kt:277 */
  119    119   
                        builder = builder.set_data(
  120    120   
                            /* JsonParserGenerator.kt:333 */
  121    121   
                            ::aws_smithy_json::deserialize::token::expect_blob_or_null(
  122    122   
                                tokens.next(),
  123    123   
                            )?, /* JsonParserGenerator.kt:277 */
  124    124   
                        );
  125    125   
                        /* JsonParserGenerator.kt:267 */
  126    126   
                    }
  127    127   
                    /* JsonParserGenerator.kt:295 */
  128    128   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  129    129   
                }
  130         -
                /* JsonParserGenerator.kt:723 */
         130  +
                /* JsonParserGenerator.kt:705 */
  131    131   
            }
  132         -
            /* JsonParserGenerator.kt:732 */
         132  +
            /* JsonParserGenerator.kt:714 */
  133    133   
            other => {
  134    134   
                return Err(
  135    135   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  136    136   
                        "expected object key or end object, found: {other:?}"
  137    137   
                    )),
  138    138   
                )
  139         -
            } /* JsonParserGenerator.kt:722 */
         139  +
            } /* JsonParserGenerator.kt:704 */
  140    140   
        }
  141         -
        /* JsonParserGenerator.kt:721 */
         141  +
        /* JsonParserGenerator.kt:703 */
  142    142   
    }
  143    143   
    /* JsonParserGenerator.kt:255 */
  144    144   
    if tokens.next().is_some() {
  145    145   
        /* JsonParserGenerator.kt:256 */
  146    146   
        return Err(
  147    147   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  148    148   
                "found more JSON tokens after completing parsing",
  149    149   
            ),
  150    150   
        );
  151    151   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_enums.rs

@@ -129,129 +278,278 @@
  149    149   
    crate::input::json_enums_input::Builder,
  150    150   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  151    151   
> {
  152    152   
    /* JsonParserGenerator.kt:158 */
  153    153   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  154    154   
        crate::protocol_serde::or_empty_doc(_value),
  155    155   
    )
  156    156   
    .peekable();
  157    157   
    let tokens = &mut tokens_owned;
  158    158   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  159         -
    /* JsonParserGenerator.kt:721 */
         159  +
    /* JsonParserGenerator.kt:703 */
  160    160   
    loop {
  161         -
        /* JsonParserGenerator.kt:722 */
         161  +
        /* JsonParserGenerator.kt:704 */
  162    162   
        match tokens.next().transpose()? {
  163         -
            /* JsonParserGenerator.kt:723 */
         163  +
            /* JsonParserGenerator.kt:705 */
  164    164   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  165    165   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  166    166   
                /* JsonParserGenerator.kt:265 */
  167    167   
                match key.to_unescaped()?.as_ref() {
  168    168   
                    /* JsonParserGenerator.kt:267 */
  169    169   
                    "fooEnum1" => {
  170    170   
                        /* JsonParserGenerator.kt:277 */
  171    171   
                        builder = builder.set_foo_enum1(
  172    172   
                            /* JsonParserGenerator.kt:361 */
  173    173   
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
  174    174   
                                tokens.next(),
  175    175   
                            )?
  176    176   
                            .map(|s|
  177    177   
                                /* JsonParserGenerator.kt:346 */s.to_unescaped().map(|u|
  178    178   
                                    /* JsonParserGenerator.kt:350 */u.into_owned()
  179    179   
                                /* JsonParserGenerator.kt:346 */) /* JsonParserGenerator.kt:361 */)
  180    180   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  181    181   
                        );
  182    182   
                        /* JsonParserGenerator.kt:267 */
  183    183   
                    }
  184    184   
                    /* JsonParserGenerator.kt:267 */
  185    185   
                    "fooEnum2" => {
  186    186   
                        /* JsonParserGenerator.kt:277 */
  187    187   
                        builder = builder.set_foo_enum2(
  188    188   
                            /* JsonParserGenerator.kt:361 */
  189    189   
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
  190    190   
                                tokens.next(),
  191    191   
                            )?
  192    192   
                            .map(|s|
  193    193   
                                /* JsonParserGenerator.kt:346 */s.to_unescaped().map(|u|
  194    194   
                                    /* JsonParserGenerator.kt:350 */u.into_owned()
  195    195   
                                /* JsonParserGenerator.kt:346 */) /* JsonParserGenerator.kt:361 */)
  196    196   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  197    197   
                        );
  198    198   
                        /* JsonParserGenerator.kt:267 */
  199    199   
                    }
  200    200   
                    /* JsonParserGenerator.kt:267 */
  201    201   
                    "fooEnum3" => {
  202    202   
                        /* JsonParserGenerator.kt:277 */
  203    203   
                        builder = builder.set_foo_enum3(
  204    204   
                            /* JsonParserGenerator.kt:361 */
  205    205   
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
  206    206   
                                tokens.next(),
  207    207   
                            )?
  208    208   
                            .map(|s|
  209    209   
                                /* JsonParserGenerator.kt:346 */s.to_unescaped().map(|u|
  210    210   
                                    /* JsonParserGenerator.kt:350 */u.into_owned()
  211    211   
                                /* JsonParserGenerator.kt:346 */) /* JsonParserGenerator.kt:361 */)
  212    212   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  213    213   
                        );
  214    214   
                        /* JsonParserGenerator.kt:267 */
  215    215   
                    }
  216    216   
                    /* JsonParserGenerator.kt:267 */
  217    217   
                    "fooEnumList" => {
  218    218   
                        /* JsonParserGenerator.kt:277 */
  219    219   
                        builder = builder.set_foo_enum_list(
  220         -
                            /* JsonParserGenerator.kt:488 */
         220  +
                            /* JsonParserGenerator.kt:481 */
  221    221   
                            crate::protocol_serde::shape_foo_enum_list::de_foo_enum_list(
  222    222   
                                tokens, _value,
  223    223   
                            )?, /* JsonParserGenerator.kt:277 */
  224    224   
                        );
  225    225   
                        /* JsonParserGenerator.kt:267 */
  226    226   
                    }
  227    227   
                    /* JsonParserGenerator.kt:267 */
  228    228   
                    "fooEnumMap" => {
  229    229   
                        /* JsonParserGenerator.kt:277 */
  230    230   
                        builder = builder.set_foo_enum_map(
  231         -
                            /* JsonParserGenerator.kt:546 */
         231  +
                            /* JsonParserGenerator.kt:528 */
  232    232   
                            crate::protocol_serde::shape_foo_enum_map::de_foo_enum_map(
  233    233   
                                tokens, _value,
  234    234   
                            )?, /* JsonParserGenerator.kt:277 */
  235    235   
                        );
  236    236   
                        /* JsonParserGenerator.kt:267 */
  237    237   
                    }
  238    238   
                    /* JsonParserGenerator.kt:267 */
  239    239   
                    "fooEnumSet" => {
  240    240   
                        /* JsonParserGenerator.kt:277 */
  241    241   
                        builder = builder.set_foo_enum_set(
  242         -
                            /* JsonParserGenerator.kt:488 */
         242  +
                            /* JsonParserGenerator.kt:481 */
  243    243   
                            crate::protocol_serde::shape_foo_enum_set::de_foo_enum_set(
  244    244   
                                tokens, _value,
  245    245   
                            )?, /* JsonParserGenerator.kt:277 */
  246    246   
                        );
  247    247   
                        /* JsonParserGenerator.kt:267 */
  248    248   
                    }
  249    249   
                    /* JsonParserGenerator.kt:295 */
  250    250   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  251    251   
                }
  252         -
                /* JsonParserGenerator.kt:723 */
         252  +
                /* JsonParserGenerator.kt:705 */
  253    253   
            }
  254         -
            /* JsonParserGenerator.kt:732 */
         254  +
            /* JsonParserGenerator.kt:714 */
  255    255   
            other => {
  256    256   
                return Err(
  257    257   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  258    258   
                        "expected object key or end object, found: {other:?}"
  259    259   
                    )),
  260    260   
                )
  261         -
            } /* JsonParserGenerator.kt:722 */
         261  +
            } /* JsonParserGenerator.kt:704 */
  262    262   
        }
  263         -
        /* JsonParserGenerator.kt:721 */
         263  +
        /* JsonParserGenerator.kt:703 */
  264    264   
    }
  265    265   
    /* JsonParserGenerator.kt:255 */
  266    266   
    if tokens.next().is_some() {
  267    267   
        /* JsonParserGenerator.kt:256 */
  268    268   
        return Err(
  269    269   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  270    270   
                "found more JSON tokens after completing parsing",
  271    271   
            ),
  272    272   
        );
  273    273   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_int_enums.rs

@@ -132,132 +272,272 @@
  152    152   
    crate::input::json_int_enums_input::Builder,
  153    153   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  154    154   
> {
  155    155   
    /* JsonParserGenerator.kt:158 */
  156    156   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  157    157   
        crate::protocol_serde::or_empty_doc(_value),
  158    158   
    )
  159    159   
    .peekable();
  160    160   
    let tokens = &mut tokens_owned;
  161    161   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  162         -
    /* JsonParserGenerator.kt:721 */
         162  +
    /* JsonParserGenerator.kt:703 */
  163    163   
    loop {
  164         -
        /* JsonParserGenerator.kt:722 */
         164  +
        /* JsonParserGenerator.kt:704 */
  165    165   
        match tokens.next().transpose()? {
  166         -
            /* JsonParserGenerator.kt:723 */
         166  +
            /* JsonParserGenerator.kt:705 */
  167    167   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  168    168   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  169    169   
                /* JsonParserGenerator.kt:265 */
  170    170   
                match key.to_unescaped()?.as_ref() {
  171    171   
                    /* JsonParserGenerator.kt:267 */
  172    172   
                    "integerEnum1" => {
  173    173   
                        /* JsonParserGenerator.kt:277 */
  174    174   
                        builder = builder.set_integer_enum1(
  175    175   
                            /* JsonParserGenerator.kt:372 */
  176    176   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  177    177   
                                tokens.next(),
  178    178   
                            )?
  179    179   
                            .map(i32::try_from)
  180    180   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  181    181   
                        );
  182    182   
                        /* JsonParserGenerator.kt:267 */
  183    183   
                    }
  184    184   
                    /* JsonParserGenerator.kt:267 */
  185    185   
                    "integerEnum2" => {
  186    186   
                        /* JsonParserGenerator.kt:277 */
  187    187   
                        builder = builder.set_integer_enum2(
  188    188   
                            /* JsonParserGenerator.kt:372 */
  189    189   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  190    190   
                                tokens.next(),
  191    191   
                            )?
  192    192   
                            .map(i32::try_from)
  193    193   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  194    194   
                        );
  195    195   
                        /* JsonParserGenerator.kt:267 */
  196    196   
                    }
  197    197   
                    /* JsonParserGenerator.kt:267 */
  198    198   
                    "integerEnum3" => {
  199    199   
                        /* JsonParserGenerator.kt:277 */
  200    200   
                        builder = builder.set_integer_enum3(
  201    201   
                            /* JsonParserGenerator.kt:372 */
  202    202   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  203    203   
                                tokens.next(),
  204    204   
                            )?
  205    205   
                            .map(i32::try_from)
  206    206   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  207    207   
                        );
  208    208   
                        /* JsonParserGenerator.kt:267 */
  209    209   
                    }
  210    210   
                    /* JsonParserGenerator.kt:267 */
  211    211   
                    "integerEnumList" => {
  212    212   
                        /* JsonParserGenerator.kt:277 */
  213    213   
                        builder = builder.set_integer_enum_list(
  214         -
                            /* JsonParserGenerator.kt:488 */
         214  +
                            /* JsonParserGenerator.kt:481 */
  215    215   
                            crate::protocol_serde::shape_integer_enum_list::de_integer_enum_list(
  216    216   
                                tokens, _value,
  217    217   
                            )?, /* JsonParserGenerator.kt:277 */
  218    218   
                        );
  219    219   
                        /* JsonParserGenerator.kt:267 */
  220    220   
                    }
  221    221   
                    /* JsonParserGenerator.kt:267 */
  222    222   
                    "integerEnumMap" => {
  223    223   
                        /* JsonParserGenerator.kt:277 */
  224    224   
                        builder = builder.set_integer_enum_map(
  225         -
                            /* JsonParserGenerator.kt:546 */
         225  +
                            /* JsonParserGenerator.kt:528 */
  226    226   
                            crate::protocol_serde::shape_integer_enum_map::de_integer_enum_map(
  227    227   
                                tokens, _value,
  228    228   
                            )?, /* JsonParserGenerator.kt:277 */
  229    229   
                        );
  230    230   
                        /* JsonParserGenerator.kt:267 */
  231    231   
                    }
  232    232   
                    /* JsonParserGenerator.kt:267 */
  233    233   
                    "integerEnumSet" => {
  234    234   
                        /* JsonParserGenerator.kt:277 */
  235    235   
                        builder = builder.set_integer_enum_set(
  236         -
                            /* JsonParserGenerator.kt:488 */
         236  +
                            /* JsonParserGenerator.kt:481 */
  237    237   
                            crate::protocol_serde::shape_integer_enum_set::de_integer_enum_set(
  238    238   
                                tokens, _value,
  239    239   
                            )?, /* JsonParserGenerator.kt:277 */
  240    240   
                        );
  241    241   
                        /* JsonParserGenerator.kt:267 */
  242    242   
                    }
  243    243   
                    /* JsonParserGenerator.kt:295 */
  244    244   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  245    245   
                }
  246         -
                /* JsonParserGenerator.kt:723 */
         246  +
                /* JsonParserGenerator.kt:705 */
  247    247   
            }
  248         -
            /* JsonParserGenerator.kt:732 */
         248  +
            /* JsonParserGenerator.kt:714 */
  249    249   
            other => {
  250    250   
                return Err(
  251    251   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  252    252   
                        "expected object key or end object, found: {other:?}"
  253    253   
                    )),
  254    254   
                )
  255         -
            } /* JsonParserGenerator.kt:722 */
         255  +
            } /* JsonParserGenerator.kt:704 */
  256    256   
        }
  257         -
        /* JsonParserGenerator.kt:721 */
         257  +
        /* JsonParserGenerator.kt:703 */
  258    258   
    }
  259    259   
    /* JsonParserGenerator.kt:255 */
  260    260   
    if tokens.next().is_some() {
  261    261   
        /* JsonParserGenerator.kt:256 */
  262    262   
        return Err(
  263    263   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  264    264   
                "found more JSON tokens after completing parsing",
  265    265   
            ),
  266    266   
        );
  267    267   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_lists.rs

@@ -129,129 +297,297 @@
  149    149   
    crate::input::json_lists_input::Builder,
  150    150   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  151    151   
> {
  152    152   
    /* JsonParserGenerator.kt:158 */
  153    153   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  154    154   
        crate::protocol_serde::or_empty_doc(_value),
  155    155   
    )
  156    156   
    .peekable();
  157    157   
    let tokens = &mut tokens_owned;
  158    158   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  159         -
    /* JsonParserGenerator.kt:721 */
         159  +
    /* JsonParserGenerator.kt:703 */
  160    160   
    loop {
  161         -
        /* JsonParserGenerator.kt:722 */
         161  +
        /* JsonParserGenerator.kt:704 */
  162    162   
        match tokens.next().transpose()? {
  163         -
            /* JsonParserGenerator.kt:723 */
         163  +
            /* JsonParserGenerator.kt:705 */
  164    164   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  165    165   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  166    166   
                /* JsonParserGenerator.kt:265 */
  167    167   
                match key.to_unescaped()?.as_ref() {
  168    168   
                    /* JsonParserGenerator.kt:267 */
  169    169   
                    "booleanList" => {
  170    170   
                        /* JsonParserGenerator.kt:277 */
  171    171   
                        builder = builder.set_boolean_list(
  172         -
                            /* JsonParserGenerator.kt:488 */
         172  +
                            /* JsonParserGenerator.kt:481 */
  173    173   
                            crate::protocol_serde::shape_boolean_list::de_boolean_list(
  174    174   
                                tokens, _value,
  175    175   
                            )?, /* JsonParserGenerator.kt:277 */
  176    176   
                        );
  177    177   
                        /* JsonParserGenerator.kt:267 */
  178    178   
                    }
  179    179   
                    /* JsonParserGenerator.kt:267 */
  180    180   
                    "enumList" => {
  181    181   
                        /* JsonParserGenerator.kt:277 */
  182    182   
                        builder = builder.set_enum_list(
  183         -
                            /* JsonParserGenerator.kt:488 */
         183  +
                            /* JsonParserGenerator.kt:481 */
  184    184   
                            crate::protocol_serde::shape_foo_enum_list::de_foo_enum_list(
  185    185   
                                tokens, _value,
  186    186   
                            )?, /* JsonParserGenerator.kt:277 */
  187    187   
                        );
  188    188   
                        /* JsonParserGenerator.kt:267 */
  189    189   
                    }
  190    190   
                    /* JsonParserGenerator.kt:267 */
  191    191   
                    "intEnumList" => {
  192    192   
                        /* JsonParserGenerator.kt:277 */
  193    193   
                        builder = builder.set_int_enum_list(
  194         -
                            /* JsonParserGenerator.kt:488 */
         194  +
                            /* JsonParserGenerator.kt:481 */
  195    195   
                            crate::protocol_serde::shape_integer_enum_list::de_integer_enum_list(
  196    196   
                                tokens, _value,
  197    197   
                            )?, /* JsonParserGenerator.kt:277 */
  198    198   
                        );
  199    199   
                        /* JsonParserGenerator.kt:267 */
  200    200   
                    }
  201    201   
                    /* JsonParserGenerator.kt:267 */
  202    202   
                    "integerList" => {
  203    203   
                        /* JsonParserGenerator.kt:277 */
  204    204   
                        builder = builder.set_integer_list(
  205         -
                            /* JsonParserGenerator.kt:488 */
         205  +
                            /* JsonParserGenerator.kt:481 */
  206    206   
                            crate::protocol_serde::shape_integer_list::de_integer_list(
  207    207   
                                tokens, _value,
  208    208   
                            )?, /* JsonParserGenerator.kt:277 */
  209    209   
                        );
  210    210   
                        /* JsonParserGenerator.kt:267 */
  211    211   
                    }
  212    212   
                    /* JsonParserGenerator.kt:267 */
  213    213   
                    "nestedStringList" => {
  214    214   
                        /* JsonParserGenerator.kt:277 */
  215    215   
                        builder = builder.set_nested_string_list(
  216         -
                            /* JsonParserGenerator.kt:488 */
         216  +
                            /* JsonParserGenerator.kt:481 */
  217    217   
                            crate::protocol_serde::shape_nested_string_list::de_nested_string_list(
  218    218   
                                tokens, _value,
  219    219   
                            )?, /* JsonParserGenerator.kt:277 */
  220    220   
                        );
  221    221   
                        /* JsonParserGenerator.kt:267 */
  222    222   
                    }
  223    223   
                    /* JsonParserGenerator.kt:267 */
  224    224   
                    "stringList" => {
  225    225   
                        /* JsonParserGenerator.kt:277 */
  226    226   
                        builder = builder.set_string_list(
  227         -
                            /* JsonParserGenerator.kt:488 */
         227  +
                            /* JsonParserGenerator.kt:481 */
  228    228   
                            crate::protocol_serde::shape_string_list::de_string_list(
  229    229   
                                tokens, _value,
  230    230   
                            )?, /* JsonParserGenerator.kt:277 */
  231    231   
                        );
  232    232   
                        /* JsonParserGenerator.kt:267 */
  233    233   
                    }
  234    234   
                    /* JsonParserGenerator.kt:267 */
  235    235   
                    "stringSet" => {
  236    236   
                        /* JsonParserGenerator.kt:277 */
  237    237   
                        builder =
  238    238   
                            builder.set_string_set(
  239         -
                                /* JsonParserGenerator.kt:488 */
         239  +
                                /* JsonParserGenerator.kt:481 */
  240    240   
                                crate::protocol_serde::shape_string_set::de_string_set(
  241    241   
                                    tokens, _value,
  242    242   
                                )?, /* JsonParserGenerator.kt:277 */
  243    243   
                            );
  244    244   
                        /* JsonParserGenerator.kt:267 */
  245    245   
                    }
  246    246   
                    /* JsonParserGenerator.kt:267 */
  247    247   
                    "myStructureList" => {
  248    248   
                        /* JsonParserGenerator.kt:277 */
  249    249   
                        builder = builder.set_structure_list(
  250         -
                            /* JsonParserGenerator.kt:488 */
         250  +
                            /* JsonParserGenerator.kt:481 */
  251    251   
                            crate::protocol_serde::shape_structure_list::de_structure_list(
  252    252   
                                tokens, _value,
  253    253   
                            )?, /* JsonParserGenerator.kt:277 */
  254    254   
                        );
  255    255   
                        /* JsonParserGenerator.kt:267 */
  256    256   
                    }
  257    257   
                    /* JsonParserGenerator.kt:267 */
  258    258   
                    "timestampList" => {
  259    259   
                        /* JsonParserGenerator.kt:277 */
  260    260   
                        builder = builder.set_timestamp_list(
  261         -
                            /* JsonParserGenerator.kt:488 */
         261  +
                            /* JsonParserGenerator.kt:481 */
  262    262   
                            crate::protocol_serde::shape_timestamp_list::de_timestamp_list(
  263    263   
                                tokens, _value,
  264    264   
                            )?, /* JsonParserGenerator.kt:277 */
  265    265   
                        );
  266    266   
                        /* JsonParserGenerator.kt:267 */
  267    267   
                    }
  268    268   
                    /* JsonParserGenerator.kt:295 */
  269    269   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  270    270   
                }
  271         -
                /* JsonParserGenerator.kt:723 */
         271  +
                /* JsonParserGenerator.kt:705 */
  272    272   
            }
  273         -
            /* JsonParserGenerator.kt:732 */
         273  +
            /* JsonParserGenerator.kt:714 */
  274    274   
            other => {
  275    275   
                return Err(
  276    276   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  277    277   
                        "expected object key or end object, found: {other:?}"
  278    278   
                    )),
  279    279   
                )
  280         -
            } /* JsonParserGenerator.kt:722 */
         280  +
            } /* JsonParserGenerator.kt:704 */
  281    281   
        }
  282         -
        /* JsonParserGenerator.kt:721 */
         282  +
        /* JsonParserGenerator.kt:703 */
  283    283   
    }
  284    284   
    /* JsonParserGenerator.kt:255 */
  285    285   
    if tokens.next().is_some() {
  286    286   
        /* JsonParserGenerator.kt:256 */
  287    287   
        return Err(
  288    288   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  289    289   
                "found more JSON tokens after completing parsing",
  290    290   
            ),
  291    291   
        );
  292    292   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_maps.rs

@@ -129,129 +252,252 @@
  149    149   
    crate::input::json_maps_input::Builder,
  150    150   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  151    151   
> {
  152    152   
    /* JsonParserGenerator.kt:158 */
  153    153   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  154    154   
        crate::protocol_serde::or_empty_doc(_value),
  155    155   
    )
  156    156   
    .peekable();
  157    157   
    let tokens = &mut tokens_owned;
  158    158   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  159         -
    /* JsonParserGenerator.kt:721 */
         159  +
    /* JsonParserGenerator.kt:703 */
  160    160   
    loop {
  161         -
        /* JsonParserGenerator.kt:722 */
         161  +
        /* JsonParserGenerator.kt:704 */
  162    162   
        match tokens.next().transpose()? {
  163         -
            /* JsonParserGenerator.kt:723 */
         163  +
            /* JsonParserGenerator.kt:705 */
  164    164   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  165    165   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  166    166   
                /* JsonParserGenerator.kt:265 */
  167    167   
                match key.to_unescaped()?.as_ref() {
  168    168   
                    /* JsonParserGenerator.kt:267 */
  169    169   
                    "denseBooleanMap" => {
  170    170   
                        /* JsonParserGenerator.kt:277 */
  171    171   
                        builder = builder.set_dense_boolean_map(
  172         -
                            /* JsonParserGenerator.kt:546 */
         172  +
                            /* JsonParserGenerator.kt:528 */
  173    173   
                            crate::protocol_serde::shape_dense_boolean_map::de_dense_boolean_map(
  174    174   
                                tokens, _value,
  175    175   
                            )?, /* JsonParserGenerator.kt:277 */
  176    176   
                        );
  177    177   
                        /* JsonParserGenerator.kt:267 */
  178    178   
                    }
  179    179   
                    /* JsonParserGenerator.kt:267 */
  180    180   
                    "denseNumberMap" => {
  181    181   
                        /* JsonParserGenerator.kt:277 */
  182    182   
                        builder = builder.set_dense_number_map(
  183         -
                            /* JsonParserGenerator.kt:546 */
         183  +
                            /* JsonParserGenerator.kt:528 */
  184    184   
                            crate::protocol_serde::shape_dense_number_map::de_dense_number_map(
  185    185   
                                tokens, _value,
  186    186   
                            )?, /* JsonParserGenerator.kt:277 */
  187    187   
                        );
  188    188   
                        /* JsonParserGenerator.kt:267 */
  189    189   
                    }
  190    190   
                    /* JsonParserGenerator.kt:267 */
  191    191   
                    "denseSetMap" => {
  192    192   
                        /* JsonParserGenerator.kt:277 */
  193    193   
                        builder = builder.set_dense_set_map(
  194         -
                            /* JsonParserGenerator.kt:546 */
         194  +
                            /* JsonParserGenerator.kt:528 */
  195    195   
                            crate::protocol_serde::shape_dense_set_map::de_dense_set_map(
  196    196   
                                tokens, _value,
  197    197   
                            )?, /* JsonParserGenerator.kt:277 */
  198    198   
                        );
  199    199   
                        /* JsonParserGenerator.kt:267 */
  200    200   
                    }
  201    201   
                    /* JsonParserGenerator.kt:267 */
  202    202   
                    "denseStringMap" => {
  203    203   
                        /* JsonParserGenerator.kt:277 */
  204    204   
                        builder = builder.set_dense_string_map(
  205         -
                            /* JsonParserGenerator.kt:546 */
         205  +
                            /* JsonParserGenerator.kt:528 */
  206    206   
                            crate::protocol_serde::shape_dense_string_map::de_dense_string_map(
  207    207   
                                tokens, _value,
  208    208   
                            )?, /* JsonParserGenerator.kt:277 */
  209    209   
                        );
  210    210   
                        /* JsonParserGenerator.kt:267 */
  211    211   
                    }
  212    212   
                    /* JsonParserGenerator.kt:267 */
  213    213   
                    "denseStructMap" => {
  214    214   
                        /* JsonParserGenerator.kt:277 */
  215    215   
                        builder = builder.set_dense_struct_map(
  216         -
                            /* JsonParserGenerator.kt:546 */
         216  +
                            /* JsonParserGenerator.kt:528 */
  217    217   
                            crate::protocol_serde::shape_dense_struct_map::de_dense_struct_map(
  218    218   
                                tokens, _value,
  219    219   
                            )?, /* JsonParserGenerator.kt:277 */
  220    220   
                        );
  221    221   
                        /* JsonParserGenerator.kt:267 */
  222    222   
                    }
  223    223   
                    /* JsonParserGenerator.kt:295 */
  224    224   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  225    225   
                }
  226         -
                /* JsonParserGenerator.kt:723 */
         226  +
                /* JsonParserGenerator.kt:705 */
  227    227   
            }
  228         -
            /* JsonParserGenerator.kt:732 */
         228  +
            /* JsonParserGenerator.kt:714 */
  229    229   
            other => {
  230    230   
                return Err(
  231    231   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  232    232   
                        "expected object key or end object, found: {other:?}"
  233    233   
                    )),
  234    234   
                )
  235         -
            } /* JsonParserGenerator.kt:722 */
         235  +
            } /* JsonParserGenerator.kt:704 */
  236    236   
        }
  237         -
        /* JsonParserGenerator.kt:721 */
         237  +
        /* JsonParserGenerator.kt:703 */
  238    238   
    }
  239    239   
    /* JsonParserGenerator.kt:255 */
  240    240   
    if tokens.next().is_some() {
  241    241   
        /* JsonParserGenerator.kt:256 */
  242    242   
        return Err(
  243    243   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  244    244   
                "found more JSON tokens after completing parsing",
  245    245   
            ),
  246    246   
        );
  247    247   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_timestamps.rs

@@ -80,80 +144,144 @@
  100    100   
    crate::input::json_timestamps_input::Builder,
  101    101   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  102    102   
> {
  103    103   
    /* JsonParserGenerator.kt:158 */
  104    104   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  105    105   
        crate::protocol_serde::or_empty_doc(_value),
  106    106   
    )
  107    107   
    .peekable();
  108    108   
    let tokens = &mut tokens_owned;
  109    109   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  110         -
    /* JsonParserGenerator.kt:721 */
         110  +
    /* JsonParserGenerator.kt:703 */
  111    111   
    loop {
  112         -
        /* JsonParserGenerator.kt:722 */
         112  +
        /* JsonParserGenerator.kt:704 */
  113    113   
        match tokens.next().transpose()? {
  114         -
            /* JsonParserGenerator.kt:723 */
         114  +
            /* JsonParserGenerator.kt:705 */
  115    115   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  116    116   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  117    117   
                /* JsonParserGenerator.kt:265 */
  118    118   
                match key.to_unescaped()?.as_ref() {
  119    119   
                    /* JsonParserGenerator.kt:267 */
  120    120   
                    "dateTime" => {
  121    121   
                        /* JsonParserGenerator.kt:277 */
  122    122   
                        builder = builder.set_date_time(
  123    123   
                            /* JsonParserGenerator.kt:421 */
  124    124   
                            ::aws_smithy_json::deserialize::token::expect_timestamp_or_null(
@@ -176,176 +232,232 @@
  196    196   
                            ::aws_smithy_json::deserialize::token::expect_timestamp_or_null(
  197    197   
                                tokens.next(),
  198    198   
                                ::aws_smithy_types::date_time::Format::EpochSeconds,
  199    199   
                            )?, /* JsonParserGenerator.kt:277 */
  200    200   
                        );
  201    201   
                        /* JsonParserGenerator.kt:267 */
  202    202   
                    }
  203    203   
                    /* JsonParserGenerator.kt:295 */
  204    204   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  205    205   
                }
  206         -
                /* JsonParserGenerator.kt:723 */
         206  +
                /* JsonParserGenerator.kt:705 */
  207    207   
            }
  208         -
            /* JsonParserGenerator.kt:732 */
         208  +
            /* JsonParserGenerator.kt:714 */
  209    209   
            other => {
  210    210   
                return Err(
  211    211   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  212    212   
                        "expected object key or end object, found: {other:?}"
  213    213   
                    )),
  214    214   
                )
  215         -
            } /* JsonParserGenerator.kt:722 */
         215  +
            } /* JsonParserGenerator.kt:704 */
  216    216   
        }
  217         -
        /* JsonParserGenerator.kt:721 */
         217  +
        /* JsonParserGenerator.kt:703 */
  218    218   
    }
  219    219   
    /* JsonParserGenerator.kt:255 */
  220    220   
    if tokens.next().is_some() {
  221    221   
        /* JsonParserGenerator.kt:256 */
  222    222   
        return Err(
  223    223   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  224    224   
                "found more JSON tokens after completing parsing",
  225    225   
            ),
  226    226   
        );
  227    227   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_json_unions.rs

@@ -130,130 +206,206 @@
  150    150   
    crate::input::json_unions_input::Builder,
  151    151   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  152    152   
> {
  153    153   
    /* JsonParserGenerator.kt:158 */
  154    154   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  155    155   
        crate::protocol_serde::or_empty_doc(_value),
  156    156   
    )
  157    157   
    .peekable();
  158    158   
    let tokens = &mut tokens_owned;
  159    159   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  160         -
    /* JsonParserGenerator.kt:721 */
         160  +
    /* JsonParserGenerator.kt:703 */
  161    161   
    loop {
  162         -
        /* JsonParserGenerator.kt:722 */
         162  +
        /* JsonParserGenerator.kt:704 */
  163    163   
        match tokens.next().transpose()? {
  164         -
            /* JsonParserGenerator.kt:723 */
         164  +
            /* JsonParserGenerator.kt:705 */
  165    165   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  166    166   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  167    167   
                /* JsonParserGenerator.kt:265 */
  168    168   
                match key.to_unescaped()?.as_ref() {
  169    169   
                    /* JsonParserGenerator.kt:267 */
  170    170   
                    "contents" => {
  171    171   
                        /* JsonParserGenerator.kt:277 */
  172    172   
                        builder = builder.set_contents(
  173         -
                            /* JsonParserGenerator.kt:697 */crate::protocol_serde::shape_my_union::de_my_union(tokens, _value)?
         173  +
                            /* JsonParserGenerator.kt:679 */crate::protocol_serde::shape_my_union::de_my_union(tokens, _value)?
  174    174   
                        /* JsonParserGenerator.kt:277 */);
  175    175   
                        /* JsonParserGenerator.kt:267 */
  176    176   
                    }
  177    177   
                    /* JsonParserGenerator.kt:295 */
  178    178   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  179    179   
                }
  180         -
                /* JsonParserGenerator.kt:723 */
         180  +
                /* JsonParserGenerator.kt:705 */
  181    181   
            }
  182         -
            /* JsonParserGenerator.kt:732 */
         182  +
            /* JsonParserGenerator.kt:714 */
  183    183   
            other => {
  184    184   
                return Err(
  185    185   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  186    186   
                        "expected object key or end object, found: {other:?}"
  187    187   
                    )),
  188    188   
                )
  189         -
            } /* JsonParserGenerator.kt:722 */
         189  +
            } /* JsonParserGenerator.kt:704 */
  190    190   
        }
  191         -
        /* JsonParserGenerator.kt:721 */
         191  +
        /* JsonParserGenerator.kt:703 */
  192    192   
    }
  193    193   
    /* JsonParserGenerator.kt:255 */
  194    194   
    if tokens.next().is_some() {
  195    195   
        /* JsonParserGenerator.kt:256 */
  196    196   
        return Err(
  197    197   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  198    198   
                "found more JSON tokens after completing parsing",
  199    199   
            ),
  200    200   
        );
  201    201   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_blob.rs

@@ -80,80 +159,159 @@
  100    100   
    crate::input::malformed_blob_input::Builder,
  101    101   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  102    102   
> {
  103    103   
    /* JsonParserGenerator.kt:158 */
  104    104   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  105    105   
        crate::protocol_serde::or_empty_doc(_value),
  106    106   
    )
  107    107   
    .peekable();
  108    108   
    let tokens = &mut tokens_owned;
  109    109   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  110         -
    /* JsonParserGenerator.kt:721 */
         110  +
    /* JsonParserGenerator.kt:703 */
  111    111   
    loop {
  112         -
        /* JsonParserGenerator.kt:722 */
         112  +
        /* JsonParserGenerator.kt:704 */
  113    113   
        match tokens.next().transpose()? {
  114         -
            /* JsonParserGenerator.kt:723 */
         114  +
            /* JsonParserGenerator.kt:705 */
  115    115   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  116    116   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  117    117   
                /* JsonParserGenerator.kt:265 */
  118    118   
                match key.to_unescaped()?.as_ref() {
  119    119   
                    /* JsonParserGenerator.kt:267 */
  120    120   
                    "blob" => {
  121    121   
                        /* JsonParserGenerator.kt:277 */
  122    122   
                        builder = builder.set_blob(
  123    123   
                            /* JsonParserGenerator.kt:333 */
  124    124   
                            ::aws_smithy_json::deserialize::token::expect_blob_or_null(
  125    125   
                                tokens.next(),
  126    126   
                            )?, /* JsonParserGenerator.kt:277 */
  127    127   
                        );
  128    128   
                        /* JsonParserGenerator.kt:267 */
  129    129   
                    }
  130    130   
                    /* JsonParserGenerator.kt:295 */
  131    131   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  132    132   
                }
  133         -
                /* JsonParserGenerator.kt:723 */
         133  +
                /* JsonParserGenerator.kt:705 */
  134    134   
            }
  135         -
            /* JsonParserGenerator.kt:732 */
         135  +
            /* JsonParserGenerator.kt:714 */
  136    136   
            other => {
  137    137   
                return Err(
  138    138   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  139    139   
                        "expected object key or end object, found: {other:?}"
  140    140   
                    )),
  141    141   
                )
  142         -
            } /* JsonParserGenerator.kt:722 */
         142  +
            } /* JsonParserGenerator.kt:704 */
  143    143   
        }
  144         -
        /* JsonParserGenerator.kt:721 */
         144  +
        /* JsonParserGenerator.kt:703 */
  145    145   
    }
  146    146   
    /* JsonParserGenerator.kt:255 */
  147    147   
    if tokens.next().is_some() {
  148    148   
        /* JsonParserGenerator.kt:256 */
  149    149   
        return Err(
  150    150   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  151    151   
                "found more JSON tokens after completing parsing",
  152    152   
            ),
  153    153   
        );
  154    154   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_boolean.rs

@@ -180,180 +259,259 @@
  200    200   
    crate::input::malformed_boolean_input::Builder,
  201    201   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  202    202   
> {
  203    203   
    /* JsonParserGenerator.kt:158 */
  204    204   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  205    205   
        crate::protocol_serde::or_empty_doc(_value),
  206    206   
    )
  207    207   
    .peekable();
  208    208   
    let tokens = &mut tokens_owned;
  209    209   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  210         -
    /* JsonParserGenerator.kt:721 */
         210  +
    /* JsonParserGenerator.kt:703 */
  211    211   
    loop {
  212         -
        /* JsonParserGenerator.kt:722 */
         212  +
        /* JsonParserGenerator.kt:704 */
  213    213   
        match tokens.next().transpose()? {
  214         -
            /* JsonParserGenerator.kt:723 */
         214  +
            /* JsonParserGenerator.kt:705 */
  215    215   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  216    216   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  217    217   
                /* JsonParserGenerator.kt:265 */
  218    218   
                match key.to_unescaped()?.as_ref() {
  219    219   
                    /* JsonParserGenerator.kt:267 */
  220    220   
                    "booleanInBody" => {
  221    221   
                        /* JsonParserGenerator.kt:277 */
  222    222   
                        builder = builder.set_boolean_in_body(
  223    223   
                            /* JsonParserGenerator.kt:303 */
  224    224   
                            ::aws_smithy_json::deserialize::token::expect_bool_or_null(
  225    225   
                                tokens.next(),
  226    226   
                            )?, /* JsonParserGenerator.kt:277 */
  227    227   
                        );
  228    228   
                        /* JsonParserGenerator.kt:267 */
  229    229   
                    }
  230    230   
                    /* JsonParserGenerator.kt:295 */
  231    231   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  232    232   
                }
  233         -
                /* JsonParserGenerator.kt:723 */
         233  +
                /* JsonParserGenerator.kt:705 */
  234    234   
            }
  235         -
            /* JsonParserGenerator.kt:732 */
         235  +
            /* JsonParserGenerator.kt:714 */
  236    236   
            other => {
  237    237   
                return Err(
  238    238   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  239    239   
                        "expected object key or end object, found: {other:?}"
  240    240   
                    )),
  241    241   
                )
  242         -
            } /* JsonParserGenerator.kt:722 */
         242  +
            } /* JsonParserGenerator.kt:704 */
  243    243   
        }
  244         -
        /* JsonParserGenerator.kt:721 */
         244  +
        /* JsonParserGenerator.kt:703 */
  245    245   
    }
  246    246   
    /* JsonParserGenerator.kt:255 */
  247    247   
    if tokens.next().is_some() {
  248    248   
        /* JsonParserGenerator.kt:256 */
  249    249   
        return Err(
  250    250   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  251    251   
                "found more JSON tokens after completing parsing",
  252    252   
            ),
  253    253   
        );
  254    254   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_byte.rs

@@ -176,176 +257,257 @@
  196    196   
    crate::input::malformed_byte_input::Builder,
  197    197   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  198    198   
> {
  199    199   
    /* JsonParserGenerator.kt:158 */
  200    200   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  201    201   
        crate::protocol_serde::or_empty_doc(_value),
  202    202   
    )
  203    203   
    .peekable();
  204    204   
    let tokens = &mut tokens_owned;
  205    205   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  206         -
    /* JsonParserGenerator.kt:721 */
         206  +
    /* JsonParserGenerator.kt:703 */
  207    207   
    loop {
  208         -
        /* JsonParserGenerator.kt:722 */
         208  +
        /* JsonParserGenerator.kt:704 */
  209    209   
        match tokens.next().transpose()? {
  210         -
            /* JsonParserGenerator.kt:723 */
         210  +
            /* JsonParserGenerator.kt:705 */
  211    211   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  212    212   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  213    213   
                /* JsonParserGenerator.kt:265 */
  214    214   
                match key.to_unescaped()?.as_ref() {
  215    215   
                    /* JsonParserGenerator.kt:267 */
  216    216   
                    "byteInBody" => {
  217    217   
                        /* JsonParserGenerator.kt:277 */
  218    218   
                        builder = builder.set_byte_in_body(
  219    219   
                            /* JsonParserGenerator.kt:372 */
  220    220   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  221    221   
                                tokens.next(),
  222    222   
                            )?
  223    223   
                            .map(i8::try_from)
  224    224   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  225    225   
                        );
  226    226   
                        /* JsonParserGenerator.kt:267 */
  227    227   
                    }
  228    228   
                    /* JsonParserGenerator.kt:295 */
  229    229   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  230    230   
                }
  231         -
                /* JsonParserGenerator.kt:723 */
         231  +
                /* JsonParserGenerator.kt:705 */
  232    232   
            }
  233         -
            /* JsonParserGenerator.kt:732 */
         233  +
            /* JsonParserGenerator.kt:714 */
  234    234   
            other => {
  235    235   
                return Err(
  236    236   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  237    237   
                        "expected object key or end object, found: {other:?}"
  238    238   
                    )),
  239    239   
                )
  240         -
            } /* JsonParserGenerator.kt:722 */
         240  +
            } /* JsonParserGenerator.kt:704 */
  241    241   
        }
  242         -
        /* JsonParserGenerator.kt:721 */
         242  +
        /* JsonParserGenerator.kt:703 */
  243    243   
    }
  244    244   
    /* JsonParserGenerator.kt:255 */
  245    245   
    if tokens.next().is_some() {
  246    246   
        /* JsonParserGenerator.kt:256 */
  247    247   
        return Err(
  248    248   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  249    249   
                "found more JSON tokens after completing parsing",
  250    250   
            ),
  251    251   
        );
  252    252   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_content_type_with_body.rs

@@ -77,77 +161,161 @@
   97     97   
    crate::input::malformed_content_type_with_body_input::Builder,
   98     98   
    ::aws_smithy_json::deserialize::error::DeserializeError,
   99     99   
> {
  100    100   
    /* JsonParserGenerator.kt:158 */
  101    101   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  102    102   
        crate::protocol_serde::or_empty_doc(_value),
  103    103   
    )
  104    104   
    .peekable();
  105    105   
    let tokens = &mut tokens_owned;
  106    106   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  107         -
    /* JsonParserGenerator.kt:721 */
         107  +
    /* JsonParserGenerator.kt:703 */
  108    108   
    loop {
  109         -
        /* JsonParserGenerator.kt:722 */
         109  +
        /* JsonParserGenerator.kt:704 */
  110    110   
        match tokens.next().transpose()? {
  111         -
            /* JsonParserGenerator.kt:723 */
         111  +
            /* JsonParserGenerator.kt:705 */
  112    112   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  113    113   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  114    114   
                /* JsonParserGenerator.kt:265 */
  115    115   
                match key.to_unescaped()?.as_ref() {
  116    116   
                    /* JsonParserGenerator.kt:267 */
  117    117   
                    "hi" => {
  118    118   
                        /* JsonParserGenerator.kt:277 */
  119    119   
                        builder = builder.set_hi(
  120    120   
                            /* JsonParserGenerator.kt:361 */
  121    121   
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
  122    122   
                                tokens.next(),
  123    123   
                            )?
  124    124   
                            .map(|s|
  125    125   
                                /* JsonParserGenerator.kt:346 */s.to_unescaped().map(|u|
  126    126   
                                    /* JsonParserGenerator.kt:355 */u.into_owned()
  127    127   
                                /* JsonParserGenerator.kt:346 */) /* JsonParserGenerator.kt:361 */)
  128    128   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  129    129   
                        );
  130    130   
                        /* JsonParserGenerator.kt:267 */
  131    131   
                    }
  132    132   
                    /* JsonParserGenerator.kt:295 */
  133    133   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  134    134   
                }
  135         -
                /* JsonParserGenerator.kt:723 */
         135  +
                /* JsonParserGenerator.kt:705 */
  136    136   
            }
  137         -
            /* JsonParserGenerator.kt:732 */
         137  +
            /* JsonParserGenerator.kt:714 */
  138    138   
            other => {
  139    139   
                return Err(
  140    140   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  141    141   
                        "expected object key or end object, found: {other:?}"
  142    142   
                    )),
  143    143   
                )
  144         -
            } /* JsonParserGenerator.kt:722 */
         144  +
            } /* JsonParserGenerator.kt:704 */
  145    145   
        }
  146         -
        /* JsonParserGenerator.kt:721 */
         146  +
        /* JsonParserGenerator.kt:703 */
  147    147   
    }
  148    148   
    /* JsonParserGenerator.kt:255 */
  149    149   
    if tokens.next().is_some() {
  150    150   
        /* JsonParserGenerator.kt:256 */
  151    151   
        return Err(
  152    152   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  153    153   
                "found more JSON tokens after completing parsing",
  154    154   
            ),
  155    155   
        );
  156    156   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_double.rs

@@ -180,180 +260,260 @@
  200    200   
    crate::input::malformed_double_input::Builder,
  201    201   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  202    202   
> {
  203    203   
    /* JsonParserGenerator.kt:158 */
  204    204   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  205    205   
        crate::protocol_serde::or_empty_doc(_value),
  206    206   
    )
  207    207   
    .peekable();
  208    208   
    let tokens = &mut tokens_owned;
  209    209   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  210         -
    /* JsonParserGenerator.kt:721 */
         210  +
    /* JsonParserGenerator.kt:703 */
  211    211   
    loop {
  212         -
        /* JsonParserGenerator.kt:722 */
         212  +
        /* JsonParserGenerator.kt:704 */
  213    213   
        match tokens.next().transpose()? {
  214         -
            /* JsonParserGenerator.kt:723 */
         214  +
            /* JsonParserGenerator.kt:705 */
  215    215   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  216    216   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  217    217   
                /* JsonParserGenerator.kt:265 */
  218    218   
                match key.to_unescaped()?.as_ref() {
  219    219   
                    /* JsonParserGenerator.kt:267 */
  220    220   
                    "doubleInBody" => {
  221    221   
                        /* JsonParserGenerator.kt:277 */
  222    222   
                        builder = builder.set_double_in_body(
  223    223   
                            /* JsonParserGenerator.kt:370 */
  224    224   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  225    225   
                                tokens.next(),
  226    226   
                            )?
  227    227   
                            .map(|v| v.to_f64_lossy()), /* JsonParserGenerator.kt:277 */
  228    228   
                        );
  229    229   
                        /* JsonParserGenerator.kt:267 */
  230    230   
                    }
  231    231   
                    /* JsonParserGenerator.kt:295 */
  232    232   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  233    233   
                }
  234         -
                /* JsonParserGenerator.kt:723 */
         234  +
                /* JsonParserGenerator.kt:705 */
  235    235   
            }
  236         -
            /* JsonParserGenerator.kt:732 */
         236  +
            /* JsonParserGenerator.kt:714 */
  237    237   
            other => {
  238    238   
                return Err(
  239    239   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  240    240   
                        "expected object key or end object, found: {other:?}"
  241    241   
                    )),
  242    242   
                )
  243         -
            } /* JsonParserGenerator.kt:722 */
         243  +
            } /* JsonParserGenerator.kt:704 */
  244    244   
        }
  245         -
        /* JsonParserGenerator.kt:721 */
         245  +
        /* JsonParserGenerator.kt:703 */
  246    246   
    }
  247    247   
    /* JsonParserGenerator.kt:255 */
  248    248   
    if tokens.next().is_some() {
  249    249   
        /* JsonParserGenerator.kt:256 */
  250    250   
        return Err(
  251    251   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  252    252   
                "found more JSON tokens after completing parsing",
  253    253   
            ),
  254    254   
        );
  255    255   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_float.rs

@@ -178,178 +258,258 @@
  198    198   
    crate::input::malformed_float_input::Builder,
  199    199   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  200    200   
> {
  201    201   
    /* JsonParserGenerator.kt:158 */
  202    202   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  203    203   
        crate::protocol_serde::or_empty_doc(_value),
  204    204   
    )
  205    205   
    .peekable();
  206    206   
    let tokens = &mut tokens_owned;
  207    207   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  208         -
    /* JsonParserGenerator.kt:721 */
         208  +
    /* JsonParserGenerator.kt:703 */
  209    209   
    loop {
  210         -
        /* JsonParserGenerator.kt:722 */
         210  +
        /* JsonParserGenerator.kt:704 */
  211    211   
        match tokens.next().transpose()? {
  212         -
            /* JsonParserGenerator.kt:723 */
         212  +
            /* JsonParserGenerator.kt:705 */
  213    213   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  214    214   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  215    215   
                /* JsonParserGenerator.kt:265 */
  216    216   
                match key.to_unescaped()?.as_ref() {
  217    217   
                    /* JsonParserGenerator.kt:267 */
  218    218   
                    "floatInBody" => {
  219    219   
                        /* JsonParserGenerator.kt:277 */
  220    220   
                        builder = builder.set_float_in_body(
  221    221   
                            /* JsonParserGenerator.kt:368 */
  222    222   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  223    223   
                                tokens.next(),
  224    224   
                            )?
  225    225   
                            .map(|v| v.to_f32_lossy()), /* JsonParserGenerator.kt:277 */
  226    226   
                        );
  227    227   
                        /* JsonParserGenerator.kt:267 */
  228    228   
                    }
  229    229   
                    /* JsonParserGenerator.kt:295 */
  230    230   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  231    231   
                }
  232         -
                /* JsonParserGenerator.kt:723 */
         232  +
                /* JsonParserGenerator.kt:705 */
  233    233   
            }
  234         -
            /* JsonParserGenerator.kt:732 */
         234  +
            /* JsonParserGenerator.kt:714 */
  235    235   
            other => {
  236    236   
                return Err(
  237    237   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  238    238   
                        "expected object key or end object, found: {other:?}"
  239    239   
                    )),
  240    240   
                )
  241         -
            } /* JsonParserGenerator.kt:722 */
         241  +
            } /* JsonParserGenerator.kt:704 */
  242    242   
        }
  243         -
        /* JsonParserGenerator.kt:721 */
         243  +
        /* JsonParserGenerator.kt:703 */
  244    244   
    }
  245    245   
    /* JsonParserGenerator.kt:255 */
  246    246   
    if tokens.next().is_some() {
  247    247   
        /* JsonParserGenerator.kt:256 */
  248    248   
        return Err(
  249    249   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  250    250   
                "found more JSON tokens after completing parsing",
  251    251   
            ),
  252    252   
        );
  253    253   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_integer.rs

@@ -180,180 +261,261 @@
  200    200   
    crate::input::malformed_integer_input::Builder,
  201    201   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  202    202   
> {
  203    203   
    /* JsonParserGenerator.kt:158 */
  204    204   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  205    205   
        crate::protocol_serde::or_empty_doc(_value),
  206    206   
    )
  207    207   
    .peekable();
  208    208   
    let tokens = &mut tokens_owned;
  209    209   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  210         -
    /* JsonParserGenerator.kt:721 */
         210  +
    /* JsonParserGenerator.kt:703 */
  211    211   
    loop {
  212         -
        /* JsonParserGenerator.kt:722 */
         212  +
        /* JsonParserGenerator.kt:704 */
  213    213   
        match tokens.next().transpose()? {
  214         -
            /* JsonParserGenerator.kt:723 */
         214  +
            /* JsonParserGenerator.kt:705 */
  215    215   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  216    216   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  217    217   
                /* JsonParserGenerator.kt:265 */
  218    218   
                match key.to_unescaped()?.as_ref() {
  219    219   
                    /* JsonParserGenerator.kt:267 */
  220    220   
                    "integerInBody" => {
  221    221   
                        /* JsonParserGenerator.kt:277 */
  222    222   
                        builder = builder.set_integer_in_body(
  223    223   
                            /* JsonParserGenerator.kt:372 */
  224    224   
                            ::aws_smithy_json::deserialize::token::expect_number_or_null(
  225    225   
                                tokens.next(),
  226    226   
                            )?
  227    227   
                            .map(i32::try_from)
  228    228   
                            .transpose()?, /* JsonParserGenerator.kt:277 */
  229    229   
                        );
  230    230   
                        /* JsonParserGenerator.kt:267 */
  231    231   
                    }
  232    232   
                    /* JsonParserGenerator.kt:295 */
  233    233   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  234    234   
                }
  235         -
                /* JsonParserGenerator.kt:723 */
         235  +
                /* JsonParserGenerator.kt:705 */
  236    236   
            }
  237         -
            /* JsonParserGenerator.kt:732 */
         237  +
            /* JsonParserGenerator.kt:714 */
  238    238   
            other => {
  239    239   
                return Err(
  240    240   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  241    241   
                        "expected object key or end object, found: {other:?}"
  242    242   
                    )),
  243    243   
                )
  244         -
            } /* JsonParserGenerator.kt:722 */
         244  +
            } /* JsonParserGenerator.kt:704 */
  245    245   
        }
  246         -
        /* JsonParserGenerator.kt:721 */
         246  +
        /* JsonParserGenerator.kt:703 */
  247    247   
    }
  248    248   
    /* JsonParserGenerator.kt:255 */
  249    249   
    if tokens.next().is_some() {
  250    250   
        /* JsonParserGenerator.kt:256 */
  251    251   
        return Err(
  252    252   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  253    253   
                "found more JSON tokens after completing parsing",
  254    254   
            ),
  255    255   
        );
  256    256   
        /* JsonParserGenerator.kt:255 */

tmp-codegen-diff/codegen-server-test/rest_json-http0x/rust-server-codegen/src/protocol_serde/shape_malformed_list.rs

@@ -80,80 +159,159 @@
  100    100   
    crate::input::malformed_list_input::Builder,
  101    101   
    ::aws_smithy_json::deserialize::error::DeserializeError,
  102    102   
> {
  103    103   
    /* JsonParserGenerator.kt:158 */
  104    104   
    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(
  105    105   
        crate::protocol_serde::or_empty_doc(_value),
  106    106   
    )
  107    107   
    .peekable();
  108    108   
    let tokens = &mut tokens_owned;
  109    109   
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
  110         -
    /* JsonParserGenerator.kt:721 */
         110  +
    /* JsonParserGenerator.kt:703 */
  111    111   
    loop {
  112         -
        /* JsonParserGenerator.kt:722 */
         112  +
        /* JsonParserGenerator.kt:704 */
  113    113   
        match tokens.next().transpose()? {
  114         -
            /* JsonParserGenerator.kt:723 */
         114  +
            /* JsonParserGenerator.kt:705 */
  115    115   
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
  116    116   
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
  117    117   
                /* JsonParserGenerator.kt:265 */
  118    118   
                match key.to_unescaped()?.as_ref() {
  119    119   
                    /* JsonParserGenerator.kt:267 */
  120    120   
                    "bodyList" => {
  121    121   
                        /* JsonParserGenerator.kt:277 */
  122    122   
                        builder = builder.set_body_list(
  123         -
                            /* JsonParserGenerator.kt:488 */
         123  +
                            /* JsonParserGenerator.kt:481 */
  124    124   
                            crate::protocol_serde::shape_simple_list::de_simple_list(
  125    125   
                                tokens, _value,
  126    126   
                            )?, /* JsonParserGenerator.kt:277 */
  127    127   
                        );
  128    128   
                        /* JsonParserGenerator.kt:267 */
  129    129   
                    }
  130    130   
                    /* JsonParserGenerator.kt:295 */
  131    131   
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:265 */
  132    132   
                }
  133         -
                /* JsonParserGenerator.kt:723 */
         133  +
                /* JsonParserGenerator.kt:705 */
  134    134   
            }
  135         -
            /* JsonParserGenerator.kt:732 */
         135  +
            /* JsonParserGenerator.kt:714 */
  136    136   
            other => {
  137    137   
                return Err(
  138    138   
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  139    139   
                        "expected object key or end object, found: {other:?}"
  140    140   
                    )),
  141    141   
                )
  142         -
            } /* JsonParserGenerator.kt:722 */
         142  +
            } /* JsonParserGenerator.kt:704 */
  143    143   
        }
  144         -
        /* JsonParserGenerator.kt:721 */
         144  +
        /* JsonParserGenerator.kt:703 */
  145    145   
    }
  146    146   
    /* JsonParserGenerator.kt:255 */
  147    147   
    if tokens.next().is_some() {
  148    148   
        /* JsonParserGenerator.kt:256 */
  149    149   
        return Err(
  150    150   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  151    151   
                "found more JSON tokens after completing parsing",
  152    152   
            ),
  153    153   
        );
  154    154   
        /* JsonParserGenerator.kt:255 */