AWS SDK

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/codec/serializer.rs

@@ -26,26 +160,172 @@

     // after each value write so the next write_string is treated as a key.
     map_depth: usize,
-28
+}
-29
 impl JsonSerializer {
     /// Creates a new JSON serializer with the given settings.
     pub(crate) fn new(settings: Arc<JsonCodecSettings>) -> Self {
         Self {
             output: String::new(),
             settings,
             needs_comma: false,
             expecting_map_key: false,
             map_depth: 0,
-39
+        }
-40
+    }
-41
     /// Finalizes the serialization and returns the output as bytes.
     pub fn finish(self) -> Vec<u8> {
         self.output.into_bytes()
-45
+    }

-46
     /// Handles comma separators and member names before writing a value.
     /// When inside a map (map_depth > 0), restores expecting_map_key after
     /// the value so the next write_string is treated as a map key.
     fn prefix(&mut self, schema: &Schema) {
         if self.needs_comma {
             self.output.push(',');
-53
+        }
         if let Some(name) = self.field_name(schema) {
             self.output.push('"');
             self.output.push_str(name);
             self.output.push_str(&crate::escape::escape_string(name));
             self.output.push_str("\":");
-58
+        }
         self.needs_comma = true;
         // Inside a map, after writing a value the next write_string should be a key.
         // This is safe because write_string checks expecting_map_key *before* calling
         // prefix(), so this only affects the *next* write_string call.
         if self.map_depth > 0 {
             self.expecting_map_key = true;
-65
+        }
-66
+    }
-67
     /// Resolves the JSON field name for a member schema.
     fn field_name<'a>(&self, schema: &'a Schema) -> Option<&'a str> {
         self.settings.member_to_field(schema)
-71
+    }
-72
     /// Gets the timestamp format to use, respecting @timestampFormat trait.
     fn get_timestamp_format(&self, schema: &Schema) -> TimestampFormat {
         if let Some(ts_trait) = schema.timestamp_format() {
             return match ts_trait.format() {
                 aws_smithy_schema::traits::TimestampFormat::EpochSeconds => {
                     TimestampFormat::EpochSeconds
-79
+                }
                 aws_smithy_schema::traits::TimestampFormat::HttpDate => TimestampFormat::HttpDate,
                 aws_smithy_schema::traits::TimestampFormat::DateTime => TimestampFormat::DateTime,
             };
-83
+        }
         self.settings.default_timestamp_format
-85
+    }
-86
     fn write_json_value(&mut self, doc: &Document) {
         use crate::serialize::JsonValueWriter;
         let writer = JsonValueWriter::new(&mut self.output);
         writer.document(doc);
-91
+    }
-92
+}
-93
 impl aws_smithy_schema::codec::FinishSerializer for JsonSerializer {
     fn finish(self) -> Vec<u8> {
         self.output.into_bytes()
-+
+    }
-+
+}
-+
 impl ShapeSerializer for JsonSerializer {
     fn write_struct(
         &mut self,
         schema: &Schema,
         value: &dyn SerializableStruct,
     ) -> Result<(), SerdeError> {
         self.prefix(schema);
         self.output.push('{');
         let saved = self.needs_comma;
         let saved_comma = self.needs_comma;
         let saved_depth = self.map_depth;
         let saved_map_key = self.expecting_map_key;
         self.needs_comma = false;
         // Reset map_depth so struct members don't trigger map-key logic in prefix().
         // Reset map state so struct members don't trigger map-key logic.
         // Restored after the struct body so an enclosing map resumes correctly.
         self.map_depth = 0;
         self.expecting_map_key = false;
         value.serialize_members(self)?;
         self.output.push('}');
         self.needs_comma = saved;
         self.needs_comma = saved_comma;
         self.map_depth = saved_depth;
         self.expecting_map_key = saved_map_key;
         Ok(())
-122
+    }
-123
     fn write_list(
         &mut self,
         schema: &Schema,
         write_elements: &dyn Fn(&mut dyn ShapeSerializer) -> Result<(), SerdeError>,
     ) -> Result<(), SerdeError> {
         self.prefix(schema);
         self.output.push('[');
         let saved = self.needs_comma;
         let saved_depth = self.map_depth;
         let saved_map_key = self.expecting_map_key;
         self.needs_comma = false;
         // Reset map_depth so list elements don't trigger map-key logic in prefix().
         // Reset map state so list elements don't trigger map-key logic in prefix().
         self.map_depth = 0;
         self.expecting_map_key = false;
         write_elements(self)?;
         self.output.push(']');
         self.needs_comma = saved;
         self.map_depth = saved_depth;
         self.expecting_map_key = saved_map_key;
         Ok(())
-144
+    }
-145
     fn write_map(
         &mut self,
         schema: &Schema,
         write_entries: &dyn Fn(&mut dyn ShapeSerializer) -> Result<(), SerdeError>,
     ) -> Result<(), SerdeError> {
         self.prefix(schema);
         self.output.push('{');

↧ Expand context

         let saved_comma = self.needs_comma;
         let saved_map_key = self.expecting_map_key;
         let saved_depth = self.map_depth;
         self.needs_comma = false;
         self.expecting_map_key = true;
         // Increment depth so prefix() knows to restore expecting_map_key after
         // each value write. write_string checks expecting_map_key *before* calling
         // prefix(), so the flag only affects the *next* write_string (the next key).
         self.map_depth += 1;
         write_entries(self)?;
         self.map_depth = saved_depth;
         self.output.push('}');
         self.needs_comma = saved_comma;
         self.expecting_map_key = saved_map_key;
         Ok(())
-168
+    }
-169
     fn write_boolean(&mut self, schema: &Schema, value: bool) -> Result<(), SerdeError> {
         self.prefix(schema);
         self.output.push_str(if value { "true" } else { "false" });

@@ -169,181 +239,275 @@

↥ Expand context

         })
-182
+    }
-183
     fn write_short(&mut self, schema: &Schema, value: i16) -> Result<(), SerdeError> {
         use std::fmt::Write;
         self.prefix(schema);
         write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
             message: e.to_string(),
         })
-190
+    }
-191
     fn write_integer(&mut self, schema: &Schema, value: i32) -> Result<(), SerdeError> {
         use std::fmt::Write;
         self.prefix(schema);
         write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
             message: e.to_string(),
         })
-198
+    }
-199
     fn write_long(&mut self, schema: &Schema, value: i64) -> Result<(), SerdeError> {

         use std::fmt::Write;
         self.prefix(schema);
         write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
             message: e.to_string(),
         })
-206
+    }
-207
     fn write_float(&mut self, schema: &Schema, value: f32) -> Result<(), SerdeError> {
         use std::fmt::Write;
         self.prefix(schema);
         write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
             message: e.to_string(),
         })
         if value.is_nan() {
             self.output.push_str("\"NaN\"");
             Ok(())
         } else if value.is_infinite() {
             if value.is_sign_positive() {
                 self.output.push_str("\"Infinity\"");
             } else {
                 self.output.push_str("\"-Infinity\"");
-+
+            }
             Ok(())
         } else {
             write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
                 message: e.to_string(),
             })
-+
+        }
-226
+    }
-227
     fn write_double(&mut self, schema: &Schema, value: f64) -> Result<(), SerdeError> {
         use std::fmt::Write;
         self.prefix(schema);
         write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
             message: e.to_string(),
         })
         if value.is_nan() {
             self.output.push_str("\"NaN\"");
             Ok(())
         } else if value.is_infinite() {
             if value.is_sign_positive() {
                 self.output.push_str("\"Infinity\"");
             } else {
                 self.output.push_str("\"-Infinity\"");
-+
+            }
             Ok(())
         } else {
             write!(&mut self.output, "{}", value).map_err(|e| SerdeError::WriteFailed {
                 message: e.to_string(),
             })
-+
+        }
-246
+    }
-247
     fn write_big_integer(&mut self, schema: &Schema, value: &BigInteger) -> Result<(), SerdeError> {
         self.prefix(schema);
         self.output.push_str(value.as_ref());
         Ok(())
-252
+    }
-253
     fn write_big_decimal(&mut self, schema: &Schema, value: &BigDecimal) -> Result<(), SerdeError> {
         self.prefix(schema);

↧ Expand context

         self.output.push_str(value.as_ref());
         Ok(())
-258
+    }
-259
     fn write_string(&mut self, schema: &Schema, value: &str) -> Result<(), SerdeError> {
         use crate::escape::escape_string;
         if self.expecting_map_key {
             // Map key: comma before (if not first entry), then "key":
             if self.needs_comma {
                 self.output.push(',');
-266
+            }
             self.output.push('"');
             self.output.push_str(&escape_string(value));
             self.output.push_str("\":");
             // The next write is the value — no comma before it
             self.needs_comma = false;
             self.expecting_map_key = false;
         } else {
             self.prefix(schema);
             self.output.push('"');

@@ -265,301 +324,361 @@

↥ Expand context

                 // Epoch seconds as number
                 self.output.push_str(&formatted);
-303
+            }
             _ => {
                 // Other formats as strings
                 self.output.push('"');
                 self.output.push_str(&formatted);
                 self.output.push('"');
-309
+            }
-310
+        }
         Ok(())
-312
+    }
-313
     fn write_document(&mut self, schema: &Schema, value: &Document) -> Result<(), SerdeError> {
         self.prefix(schema);
         self.write_json_value(value);
         Ok(())
-318
+    }
-319
     fn write_null(&mut self, schema: &Schema) -> Result<(), SerdeError> {

         self.prefix(schema);
         self.output.push_str("null");
         Ok(())
-324
+    }
-325
+}
-326
 #[cfg(test)]
 mod tests {
     use super::*;
     use aws_smithy_schema::prelude::*;
     use aws_smithy_schema::ShapeType;
-332
     #[test]
     fn test_write_boolean() {
         let mut ser = JsonSerializer::new(Arc::new(JsonCodecSettings::default()));
         ser.write_boolean(&BOOLEAN, true).unwrap();
         let output = ser.finish();
         assert_eq!(String::from_utf8(output).unwrap(), "true");
-339
+    }
-340
     #[test]

↧ Expand context

     fn test_write_string() {
         let mut ser = JsonSerializer::new(Arc::new(JsonCodecSettings::default()));
         ser.write_string(&STRING, "hello").unwrap();
         let output = ser.finish();
         assert_eq!(String::from_utf8(output).unwrap(), "\"hello\"");
-347
+    }
-348
     #[test]
     fn test_write_integer() {
         let mut ser = JsonSerializer::new(Arc::new(JsonCodecSettings::default()));
         ser.write_integer(&INTEGER, 42).unwrap();
         let output = ser.finish();
         assert_eq!(String::from_utf8(output).unwrap(), "42");
-355
+    }
-356
     #[test]
     fn test_write_null() {
         let mut ser = JsonSerializer::new(Arc::new(JsonCodecSettings::default()));
         ser.write_null(&STRING).unwrap();
         let output = ser.finish();

@@ -607,644 +637,719 @@

↥ Expand context

-644
+        )
         .with_json_name("Baz");
-646
         struct TestStruct;
         impl SerializableStruct for TestStruct {
             fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                 s.write_string(&FOO_MEMBER, "hello")?;
                 s.write_integer(&BAR_MEMBER, 42)?;
                 Ok(())
-653
+            }
-654
+        }
-655
         // With use_json_name=true (default), "bar" should serialize as "Baz"
         let struct_schema = Schema::new(
             aws_smithy_schema::shape_id!("test", "MyStruct"),
             aws_smithy_schema::ShapeType::Structure,
         );
         let mut ser = JsonSerializer::new(Arc::new(JsonCodecSettings::default()));
         ser.write_struct(&struct_schema, &TestStruct).unwrap();
         let output = String::from_utf8(ser.finish()).unwrap();

         assert_eq!(output, r#"{"foo":"hello","Baz":42}"#);
-665
         // With use_json_name=false, "bar" should stay as "bar"
         let mut ser = JsonSerializer::new(Arc::new(
             JsonCodecSettings::builder().use_json_name(false).build(),
         ));
         ser.write_struct(&struct_schema, &TestStruct).unwrap();
         let output = String::from_utf8(ser.finish()).unwrap();
         assert_eq!(output, r#"{"foo":"hello","bar":42}"#);
-673
+    }
-+
     #[test]
     fn struct_inside_map_serializes_member_names_correctly() {
         // Regression test: when a struct is a map value, the map's expecting_map_key
         // flag must not leak into the struct's member serialization.
         use aws_smithy_schema::serde::{SerializableStruct, ShapeSerializer};
-+
         static INNER_NAME: Schema = Schema::new_member(
             aws_smithy_schema::shape_id!("test", "Inner"),
             ShapeType::String,
             "name",
 ,
         );
         static INNER_MEMBERS: &[&Schema] = &[&INNER_NAME];
         static INNER_SCHEMA: Schema = Schema::new_struct(
             aws_smithy_schema::shape_id!("test", "Inner"),
             ShapeType::Structure,
             INNER_MEMBERS,
         );
-+
         struct Inner;
         impl SerializableStruct for Inner {
             fn serialize_members(
                 &self,
                 ser: &mut dyn ShapeSerializer,
             ) -> Result<(), aws_smithy_schema::serde::SerdeError> {
                 ser.write_string(&INNER_NAME, "Alice")
-+
+            }
-+
+        }
-+
         static MAP_SCHEMA: Schema = Schema::new(
             aws_smithy_schema::shape_id!("test", "MyMap"),
             ShapeType::Map,
         );
-+
         let mut ser = JsonSerializer::new(Arc::new(JsonCodecSettings::default()));
         ser.write_map(&MAP_SCHEMA, &|ser| {
             ser.write_string(&aws_smithy_schema::prelude::STRING, "key1")?;
             ser.write_struct(&INNER_SCHEMA, &Inner)?;
             Ok(())
         })
         .unwrap();
         let output = String::from_utf8(ser.finish()).unwrap();
         assert_eq!(output, r#"{"key1":{"name":"Alice"}}"#);
-+
+    }
-719
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/lib.rs

@@ -1,1 +23,24 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 /* Automatically managed default lints */
 #![cfg_attr(docsrs, feature(doc_cfg))]
 /* End of automatically managed default lints */
 #![allow(clippy::derive_partial_eq_without_eq)]
 #![warn(
     // missing_docs,
     rustdoc::missing_crate_level_docs,

     unreachable_pub,
     // Enabling this requires fixing a macro but I don't understand how to do that.
     // rust_2018_idioms
 )]
-17
 //! JSON Abstractions for Smithy
-19
 pub mod codec;
 pub mod deserialize;
 mod escape;
 pub mod protocol;
 pub mod serialize;

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/protocol/aws_json_rpc.rs

@@ -0,1 +0,198 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! AWS JSON RPC protocol implementation (`awsJson1_0` and `awsJson1_1`).
 //!
 //! # Protocol behaviors
 //!
 //! - HTTP method: always POST, path: always `/`
 //! - `X-Amz-Target`: `{ServiceName}.{OperationName}` (required)
 //! - Does **not** use `@jsonName` trait
 //! - Default timestamp format: `epoch-seconds`
 //! - Ignores HTTP binding traits
 //!
 //! # Differences between 1.0 and 1.1
 //!
 //! - Content-Type: `application/x-amz-json-1.0` vs `application/x-amz-json-1.1`
 //! - Error `__type` serialization differs on the server side, but clients MUST
 //!   accept either format for both versions.
-+
 use crate::codec::{JsonCodec, JsonCodecSettings};
 use aws_smithy_runtime_api::client::orchestrator::Metadata;
 use aws_smithy_schema::http_protocol::HttpRpcProtocol;
 use aws_smithy_schema::{shape_id, Schema, ShapeId};
 use aws_smithy_types::config_bag::ConfigBag;
-+
 /// AWS JSON RPC protocol (`awsJson1_0` / `awsJson1_1`).
 #[derive(Debug)]
 pub struct AwsJsonRpcProtocol {
     inner: HttpRpcProtocol<JsonCodec>,
     target_prefix: String,
-+
+}
-+
 impl AwsJsonRpcProtocol {
     /// Creates an AWS JSON 1.0 protocol instance.
     ///
     /// `target_prefix` is the Smithy service shape name used in the `X-Amz-Target` header
     /// (e.g., `"TrentService"` for KMS, `"DynamoDB_20120810"` for DynamoDB).
     pub fn aws_json_1_0(target_prefix: impl Into<String>) -> Self {
         Self::new(
             shape_id!("aws.protocols", "awsJson1_0"),
             "application/x-amz-json-1.0",
             target_prefix.into(),
-+
+        )
-+
+    }
-+
     /// Creates an AWS JSON 1.1 protocol instance.
     ///
     /// `target_prefix` is the Smithy service shape name used in the `X-Amz-Target` header.
     pub fn aws_json_1_1(target_prefix: impl Into<String>) -> Self {
         Self::new(
             shape_id!("aws.protocols", "awsJson1_1"),
             "application/x-amz-json-1.1",
             target_prefix.into(),
-+
+        )
-+
+    }
-+
     fn new(protocol_id: ShapeId, content_type: &'static str, target_prefix: String) -> Self {
         let codec = JsonCodec::new(
             JsonCodecSettings::builder()
                 .use_json_name(false)
                 .default_timestamp_format(aws_smithy_types::date_time::Format::EpochSeconds)
                 .build(),
         );
         Self {
             inner: HttpRpcProtocol::new(protocol_id, codec, content_type),
             target_prefix,
-+
+        }
-+
+    }
-+
+}
-+
 impl aws_smithy_schema::protocol::ClientProtocol for AwsJsonRpcProtocol {
     fn protocol_id(&self) -> &ShapeId {
         self.inner.protocol_id()
-+
+    }
-+
     fn serialize_request(
         &self,
         input: &dyn aws_smithy_schema::serde::SerializableStruct,
         input_schema: &Schema,
         endpoint: &str,
         cfg: &ConfigBag,
     ) -> Result<aws_smithy_runtime_api::http::Request, aws_smithy_schema::serde::SerdeError> {
         let mut request = self
             .inner
             .serialize_request(input, input_schema, endpoint, cfg)?;
         if let Some(metadata) = cfg.load::<Metadata>() {
             request.headers_mut().insert(
                 "X-Amz-Target",
                 format!("{}.{}", self.target_prefix, metadata.name()),
             );
-+
+        }
         Ok(request)
-+
+    }
-+
     fn deserialize_response<'a>(
         &self,
         response: &'a aws_smithy_runtime_api::http::Response,
         output_schema: &Schema,
         cfg: &ConfigBag,
     ) -> Result<
         Box<dyn aws_smithy_schema::serde::ShapeDeserializer + 'a>,
         aws_smithy_schema::serde::SerdeError,
     > {
         self.inner
             .deserialize_response(response, output_schema, cfg)
-+
+    }
-+
+}
-+
 #[cfg(test)]
 mod tests {
     use super::*;
     use aws_smithy_schema::protocol::ClientProtocol;
     use aws_smithy_schema::serde::{SerdeError, SerializableStruct, ShapeSerializer};
     use aws_smithy_schema::ShapeType;
     use aws_smithy_types::config_bag::Layer;
-+
     struct EmptyStruct;
     impl SerializableStruct for EmptyStruct {
         fn serialize_members(&self, _: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
             Ok(())
-+
+        }
-+
+    }
-+
     static TEST_SCHEMA: aws_smithy_schema::Schema =
         aws_smithy_schema::Schema::new(shape_id!("test", "Input"), ShapeType::Structure);
-+
     fn cfg_with_metadata(service: &str, operation: &str) -> ConfigBag {
         let mut layer = Layer::new("test");
         layer.store_put(Metadata::new(operation.to_string(), service.to_string()));
         ConfigBag::of_layers(vec![layer])
-+
+    }
-+
     #[test]
     fn json_1_0_content_type() {
         let request = AwsJsonRpcProtocol::aws_json_1_0("TestService")
             .serialize_request(
                 &EmptyStruct,
                 &TEST_SCHEMA,
                 "https://example.com",
                 &ConfigBag::base(),
-+
+            )
             .unwrap();
         assert_eq!(
             request.headers().get("Content-Type").unwrap(),
             "application/x-amz-json-1.0"
         );
-+
+    }
-+
     #[test]
     fn json_1_1_content_type() {
         let request = AwsJsonRpcProtocol::aws_json_1_1("TestService")
             .serialize_request(
                 &EmptyStruct,
                 &TEST_SCHEMA,
                 "https://example.com",
                 &ConfigBag::base(),
-+
+            )
             .unwrap();
         assert_eq!(
             request.headers().get("Content-Type").unwrap(),
             "application/x-amz-json-1.1"
         );
-+
+    }
-+
     #[test]
     fn sets_x_amz_target() {
         let cfg = cfg_with_metadata("MyService", "DoThing");
         let request = AwsJsonRpcProtocol::aws_json_1_0("MyService")
             .serialize_request(&EmptyStruct, &TEST_SCHEMA, "https://example.com", &cfg)
             .unwrap();
         assert_eq!(
             request.headers().get("X-Amz-Target").unwrap(),
             "MyService.DoThing"
         );
-+
+    }
-+
     #[test]
     fn json_1_0_protocol_id() {
         assert_eq!(
             AwsJsonRpcProtocol::aws_json_1_0("Svc")
                 .protocol_id()
                 .as_str(),
             "aws.protocols#awsJson1_0"
         );
-+
+    }
-+
     #[test]
     fn json_1_1_protocol_id() {
         assert_eq!(
             AwsJsonRpcProtocol::aws_json_1_1("Svc")
                 .protocol_id()
                 .as_str(),
             "aws.protocols#awsJson1_1"
         );
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/protocol/aws_rest_json_1.rs

@@ -0,1 +0,87 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! AWS REST JSON 1.0 protocol implementation.
 //!
 //! This module provides [`AwsRestJsonProtocol`], which constructs an
 //! [`HttpBindingProtocol`] with a [`JsonCodec`] configured for the
 //! `aws.protocols#restJson1` protocol:
 //!
 //! - Uses `@jsonName` trait for JSON property names
 //! - Default timestamp format: `epoch-seconds`
 //! - Content-Type: `application/json`
-+
 use crate::codec::{JsonCodec, JsonCodecSettings};
 use aws_smithy_schema::http_protocol::HttpBindingProtocol;
 use aws_smithy_schema::{Schema, ShapeId};
 use aws_smithy_types::config_bag::ConfigBag;
-+
 static PROTOCOL_ID: ShapeId = ShapeId::from_static("aws.protocols", "restJson1", "");
-+
 /// AWS REST JSON 1.0 protocol (`aws.protocols#restJson1`).
 ///
 /// This is a thin configuration wrapper that constructs an [`HttpBindingProtocol`]
 /// with a [`JsonCodec`] using REST JSON settings. The `HttpBindingProtocol` handles
 /// splitting members between HTTP bindings and the JSON payload.
 #[derive(Debug)]
 pub struct AwsRestJsonProtocol {
     inner: HttpBindingProtocol<JsonCodec>,
-+
+}
-+
 impl AwsRestJsonProtocol {
     /// Creates a new REST JSON protocol with default settings.
     pub fn new() -> Self {
         let codec = JsonCodec::new(
             JsonCodecSettings::builder()
                 .use_json_name(true)
                 .default_timestamp_format(aws_smithy_types::date_time::Format::EpochSeconds)
                 .build(),
         );
         Self {
             inner: HttpBindingProtocol::new(PROTOCOL_ID, codec, "application/json"),
-+
+        }
-+
+    }
-+
     /// Returns a reference to the inner `HttpBindingProtocol`.
     pub fn inner(&self) -> &HttpBindingProtocol<JsonCodec> {
         &self.inner
-+
+    }
-+
+}
-+
 impl Default for AwsRestJsonProtocol {
     fn default() -> Self {
         Self::new()
-+
+    }
-+
+}
-+
 impl aws_smithy_schema::protocol::ClientProtocol for AwsRestJsonProtocol {
     fn protocol_id(&self) -> &ShapeId {
         self.inner.protocol_id()
-+
+    }
-+
     fn serialize_request(
         &self,
         input: &dyn aws_smithy_schema::serde::SerializableStruct,
         input_schema: &Schema,
         endpoint: &str,
         cfg: &ConfigBag,
     ) -> Result<aws_smithy_runtime_api::http::Request, aws_smithy_schema::serde::SerdeError> {
         self.inner
             .serialize_request(input, input_schema, endpoint, cfg)
-+
+    }
-+
     fn deserialize_response<'a>(
         &self,
         response: &'a aws_smithy_runtime_api::http::Response,
         output_schema: &Schema,
         cfg: &ConfigBag,
     ) -> Result<
         Box<dyn aws_smithy_schema::serde::ShapeDeserializer + 'a>,
         aws_smithy_schema::serde::SerdeError,
     > {
         self.inner
             .deserialize_response(response, output_schema, cfg)
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/protocol/mod.rs

@@ -0,1 +0,9 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Protocol implementations for JSON-based Smithy protocols.
-+
 pub mod aws_json_rpc;
 pub mod aws_rest_json_1;

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/Cargo.toml

@@ -1,1 +73,73 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-legacy-http"
 version = "0.62.14"
 version = "0.62.15"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "Smithy HTTP-0x logic for smithy-rs."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [features]
 event-stream = ["aws-smithy-eventstream", "aws-smithy-http/event-stream"]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
-20
 [dependencies]
 bytes = "1.11.1"
 bytes-utils = "0.1"
 percent-encoding = "2.3.1"
 pin-project-lite = "0.2.14"
 pin-utils = "0.1.0"
 tracing = "0.1.44"
 futures-core = "0.3.31"
-29
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 optional = true
 version = "0.60.20"
-34
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 optional = true
 version = "0.63.6"
-39
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 version = "1.11.6"
 version = "1.11.7"
-44
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["byte-stream-poll-next", "http-body-0-4-x"]
 version = "1.4.7"
-49
 [dependencies.http-02x]
 package = "http"
 version = "0.2.12"
-53

↧ Expand context

 [dependencies.http-1x]
 package = "http"
 version = "1.3.1"
-57
 [dependencies.http-body-04x]
 package = "http-body"
 version = "0.4.6"
-61
 [dependencies.futures-util]
 version = "0.3.29"
 default-features = false
-65
 [dev-dependencies]
 async-stream = "0.3"
 proptest = "1"
-69
 [dev-dependencies.futures-util]
 version = "0.3.29"
 default-features = false
-73

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-mocks/Cargo.toml

@@ -1,1 +0,45 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-mocks"
 version = "0.2.6"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Testing utilities for smithy-rs generated clients"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16

 [dependencies]
 http = "1.3.1"
-19
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.4.7"
-23
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x", "test-util"]
 version = "1.11.6"
 version = "1.11.7"
-28
 [dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util"]
 version = "1.1.12"
 [dev-dependencies.tokio]
 version = "1"
 features = ["full"]
-36
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["rt-tokio"]
 version = "1.2.14"
-41
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.10.3"
 version = "1.10.4"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/Cargo.toml

@@ -1,1 +21,21 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-observability"
 version = "0.2.6"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Smithy observability implementation."
 edition = "2021"

 license = "Apache-2.0"
 repository = "https://github.com/awslabs/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 version = "1.11.6"
 version = "1.11.7"
-19
 [dev-dependencies]
 serial_test = "3.1.1"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-protocol-test/Cargo.toml

@@ -6,6 +46,46 @@

↥ Expand context

 description = "A collection of library functions to validate HTTP requests against Smithy protocol tests."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [features]
 default = ["http-02x"]
 http-02x = ["dep:http-0x"]
 http-1x = ["dep:http-1x"]
-21
 [dependencies]
 assert-json-diff = "2"
 base64-simd = "0.8"
 cbor-diag = "0.1.12"

 ciborium = "0.2"
 pretty_assertions = "1.3"
 regex-lite = "0.1.5"
 roxmltree = "0.14.1"
 serde_json = "1.0.146"
 thiserror = "2"
-32
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client"]
 version = "1.11.6"
 version = "1.11.7"
-37
 [dependencies.http-0x]
 package = "http"
 version = "0.2.12"
 optional = true
-42
 [dependencies.http-1x]
 package = "http"
 version = "1.3.1"
 optional = true

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/Cargo.toml

@@ -1,1 +34,34 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-runtime-api"
 version = "1.11.6"
 version = "1.11.7"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]
 description = "Smithy runtime types."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]

↧ Expand context

 rustdoc-args = ["--cfg", "docsrs"]
-16
 [package.metadata.smithy-rs-release-tooling]
 stable = true
-19
 [features]
 default = []
 client = []
 http-auth = ["dep:zeroize"]
 test-util = ["aws-smithy-types/test-util", "http-1x"]
 http-02x = []
 http-1x = []
-27
 [dependencies]
 bytes = "1.11.1"
 pin-project-lite = "0.2.14"
 tracing = "0.1.44"
-32
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/ser_de.rs

@@ -25,25 +110,178 @@

↥ Expand context

     /// code generated runtime plugin, which is aware of the correct input/output/error types.
     fn serialize_input(&self, input: Input, cfg: &mut ConfigBag) -> Result<HttpRequest, BoxError>;
-27
+}
-28
 /// A shared request serializer.
 ///
 /// This is a simple shared ownership wrapper type for the [`SerializeRequest`] trait.
 #[derive(Clone, Debug)]
 pub struct SharedRequestSerializer(Arc<dyn SerializeRequest>);
-34
 impl SharedRequestSerializer {
     /// Creates a new shared request serializer.
     pub fn new(serializer: impl SerializeRequest + 'static) -> Self {
         Self(Arc::new(serializer))
-39
+    }
-40
+}
-41
 impl SerializeRequest for SharedRequestSerializer {
     fn serialize_input(&self, input: Input, cfg: &mut ConfigBag) -> Result<HttpRequest, BoxError> {
         self.0.serialize_input(input, cfg)

-45
+    }
-46
+}
-47
 impl Storable for SharedRequestSerializer {
     type Storer = StoreReplace<Self>;
-50
+}
-51
 impl_shared_conversions!(convert SharedRequestSerializer from SerializeRequest using SharedRequestSerializer::new);
-53
 /// Deserialization implementation that converts an [`HttpResponse`] into an [`Output`] or [`Error`].
 ///
 /// This trait uses a backward-compatible versioning pattern for methods that need
 /// access to [`ConfigBag`]. Each method has a `_with_config` variant:
 ///
 /// - **Legacy implementations** override the original method (without config).
 ///   The default `_with_config` variant delegates to it, ignoring the config.
 /// - **New implementations** override the `_with_config` variant.
 ///   The default original method delegates to it with an empty config bag.
 ///
 /// The orchestrator always calls the `_with_config` variants.
 pub trait DeserializeResponse: Send + Sync + fmt::Debug {
     /// For streaming requests, deserializes the response headers.
     ///
     /// The orchestrator will call `deserialize_streaming` first, and if it returns `None`,
     /// then it will continue onto `deserialize_nonstreaming`. This method should only be
     /// implemented for streaming requests where the streaming response body needs to be a part
     /// of the deserialized output.
     /// The orchestrator will call [`deserialize_streaming_with_config`](Self::deserialize_streaming_with_config)
     /// first, and if it returns `None`, then it will continue onto
     /// [`deserialize_nonstreaming_with_config`](Self::deserialize_nonstreaming_with_config).
     ///
     /// Override this or [`deserialize_streaming_with_config`](Self::deserialize_streaming_with_config),
     /// but not both.
     #[deprecated(
         note = "Implement `deserialize_streaming_with_config` instead. This method will be removed in a future release."
     )]
     fn deserialize_streaming(
         &self,
         response: &mut HttpResponse,
     ) -> Option<Result<Output, OrchestratorError<Error>>> {
         let _ = response;
         None
-83
+    }
-84
     /// For streaming requests, deserializes the response headers with access to the config bag.
     ///
     /// This is the method called by the orchestrator. The default implementation
     /// delegates to [`deserialize_streaming`](Self::deserialize_streaming), ignoring the config.
     fn deserialize_streaming_with_config(
         &self,
         response: &mut HttpResponse,
         _cfg: &ConfigBag,
     ) -> Option<Result<Output, OrchestratorError<Error>>> {
         #[allow(deprecated)]
         self.deserialize_streaming(response)
-+
+    }
-+
     /// Deserialize the entire response including its body into an output or error.
     ///
     /// Override this or [`deserialize_nonstreaming_with_config`](Self::deserialize_nonstreaming_with_config),
     /// but not both.
     #[deprecated(
         note = "Implement `deserialize_nonstreaming_with_config` instead. This method will be removed in a future release."
     )]
     fn deserialize_nonstreaming(
         &self,
         response: &HttpResponse,
     ) -> Result<Output, OrchestratorError<Error>>;
     ) -> Result<Output, OrchestratorError<Error>> {
         self.deserialize_nonstreaming_with_config(response, &ConfigBag::base())
-+
+    }
-+
     /// Deserialize the entire response including its body into an output or error,
     /// with access to the config bag.
     ///
     /// This is the method called by the orchestrator. The default implementation
     /// delegates to [`deserialize_nonstreaming`](Self::deserialize_nonstreaming),
     /// ignoring the config bag.
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &HttpResponse,
         _cfg: &ConfigBag,
     ) -> Result<Output, OrchestratorError<Error>> {
         #[allow(deprecated)]
         self.deserialize_nonstreaming(response)
-+
+    }
-126
+}
-127
 /// Shared response deserializer.
 ///
 /// This is a simple shared ownership wrapper type for the [`DeserializeResponse`] trait.
 #[derive(Debug)]
 pub struct SharedResponseDeserializer(Arc<dyn DeserializeResponse>);
-133
 impl SharedResponseDeserializer {
     /// Creates a new [`SharedResponseDeserializer`].
     pub fn new(serializer: impl DeserializeResponse + 'static) -> Self {
         Self(Arc::new(serializer))
-138
+    }
-139
+}
-140
 #[allow(deprecated)]
 impl DeserializeResponse for SharedResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &HttpResponse,
     ) -> Result<Output, OrchestratorError<Error>> {
         self.0.deserialize_nonstreaming(response)
-148
+    }
-149
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &HttpResponse,
         cfg: &ConfigBag,
     ) -> Result<Output, OrchestratorError<Error>> {
         self.0.deserialize_nonstreaming_with_config(response, cfg)
-+
+    }
-+
     fn deserialize_streaming(
         &self,
         response: &mut HttpResponse,
     ) -> Option<Result<Output, OrchestratorError<Error>>> {
         self.0.deserialize_streaming(response)
-163
+    }
-+
     fn deserialize_streaming_with_config(
         &self,
         response: &mut HttpResponse,
         cfg: &ConfigBag,
     ) -> Option<Result<Output, OrchestratorError<Error>>> {
         self.0.deserialize_streaming_with_config(response, cfg)
-+
+    }
-172
+}
-173
 impl Storable for SharedResponseDeserializer {
     type Storer = StoreReplace<Self>;
-176
+}
-177
 impl_shared_conversions!(convert SharedResponseDeserializer from DeserializeResponse using SharedResponseDeserializer::new);

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/http/error.rs

@@ -1,1 +155,164 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Error types for HTTP requests/responses.
-7
 use crate::box_error::BoxError;
 use http_02x::header::{InvalidHeaderName, InvalidHeaderValue};
 use http_02x::uri::InvalidUri;
 use std::error::Error;
 use std::fmt::{Debug, Display, Formatter};
 use std::str::Utf8Error;
-14
 #[derive(Debug)]
 /// An error occurred constructing an Http Request.
 ///
 /// This is normally due to configuration issues, internal SDK bugs, or other user error.

 pub struct HttpError {
     kind: Kind,
     source: Option<BoxError>,
-22
+}
-23
 #[derive(Debug)]
 enum Kind {
     InvalidExtensions,
     InvalidHeaderName,
     InvalidHeaderValue,
     InvalidMethod,
     InvalidStatusCode,
     InvalidUri,
     InvalidUriParts,
     MissingAuthority,
     MissingScheme,
     NonUtf8Header(NonUtf8Header),
-36
+}
-37
 #[derive(Debug)]
 pub(super) struct NonUtf8Header {
     error: Utf8Error,
     value: Vec<u8>,
     name: Option<String>,
-43
+}
-44
 impl NonUtf8Header {
     #[cfg(any(feature = "http-1x", feature = "http-02x"))]
     pub(super) fn new(name: String, value: Vec<u8>, error: Utf8Error) -> Self {
         Self {
             error,
             value,
             name: Some(name),
-52
+        }
-53
+    }
-54
     pub(super) fn new_missing_name(value: Vec<u8>, error: Utf8Error) -> Self {
         Self {
             error,
             value,
             name: None,
-60
+        }
-61
+    }
-62
+}
-63
 impl HttpError {
     pub(super) fn invalid_extensions() -> Self {
         Self {
             kind: Kind::InvalidExtensions,
             source: None,
-69
+        }
-70
+    }
-71
     pub(super) fn invalid_header_name(err: InvalidHeaderName) -> Self {
         Self {
             kind: Kind::InvalidHeaderName,
             source: Some(Box::new(err)),
-76
+        }
-77
+    }
-78
     pub(super) fn invalid_method(err: http_1x::method::InvalidMethod) -> Self {
         Self {
             kind: Kind::InvalidMethod,
             source: Some(Box::new(err)),
-+
+        }
-+
+    }
-+
     pub(super) fn invalid_header_value(err: InvalidHeaderValue) -> Self {
         Self {
             kind: Kind::InvalidHeaderValue,
             source: Some(Box::new(err)),
-90
+        }
-91
+    }
-92
     pub(super) fn invalid_status_code() -> Self {
         Self {
             kind: Kind::InvalidStatusCode,
             source: None,
-97
+        }
-98
+    }
-99
     pub(super) fn invalid_uri(err: InvalidUri) -> Self {
         Self {
             kind: Kind::InvalidUri,
             source: Some(Box::new(err)),
-104
+        }
-105
+    }
-106
     pub(super) fn invalid_uri_parts(err: http_02x::Error) -> Self {
         Self {
             kind: Kind::InvalidUriParts,
             source: Some(Box::new(err)),
-111
+        }
-112
+    }
-113
     pub(super) fn missing_authority() -> Self {
         Self {
             kind: Kind::MissingAuthority,
             source: None,
-118
+        }
-119
+    }
-120
     pub(super) fn missing_scheme() -> Self {
         Self {
             kind: Kind::MissingScheme,
             source: None,
-125
+        }
-126
+    }
-127
     pub(super) fn non_utf8_header(non_utf8_header: NonUtf8Header) -> Self {
         Self {
             kind: Kind::NonUtf8Header(non_utf8_header),
             source: None,
-132
+        }
-133
+    }
-134
+}
-135
 impl Display for HttpError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         use Kind::*;
         match &self.kind {
             InvalidExtensions => write!(f, "Extensions were provided during initialization. This prevents the request format from being converted."),
             InvalidHeaderName => write!(f, "invalid header name"),
             InvalidHeaderValue => write!(f, "invalid header value"),
             InvalidMethod => write!(f, "invalid HTTP method"),
             InvalidStatusCode => write!(f, "invalid HTTP status code"),
             InvalidUri => write!(f, "endpoint is not a valid URI"),
             InvalidUriParts => write!(f, "endpoint parts are not valid"),
             MissingAuthority => write!(f, "endpoint must contain authority"),
             MissingScheme => write!(f, "endpoint must contain scheme"),
             NonUtf8Header(hv) => {
                 // In some cases, we won't know the key so we default to "<unknown>".
                 let key = hv.name.as_deref().unwrap_or("<unknown>");
                 let value = String::from_utf8_lossy(&hv.value);
                 let index = hv.error.valid_up_to();

↧ Expand context

                 write!(f, "header `{key}={value}` contains non-UTF8 octet at index {index}")
             },
-156
+        }
-157
+    }
-158
+}
-159
 impl Error for HttpError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         self.source.as_ref().map(|err| err.as_ref() as _)
-163
+    }
-164
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/http/request.rs

@@ -1,1 +60,60 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Http Request Types
-7
 use crate::http::extensions::Extensions;
 use crate::http::Headers;
 use crate::http::HttpError;
 use aws_smithy_types::body::SdkBody;
 use std::borrow::Cow;
-13
 /// Parts struct useful for structural decomposition that the [`Request`] type can be converted into.
 #[non_exhaustive]
 pub struct RequestParts<B = SdkBody> {
     /// Request URI.
     pub uri: Uri,
     /// Request headers.

     pub headers: Headers,
     /// Request body.
     pub body: B,
-23
+}
-24
 #[derive(Debug)]
 /// An HTTP Request Type
 pub struct Request<B = SdkBody> {
     body: B,
     uri: Uri,
     method: http_02x::Method,
     method: http_1x::Method,
     extensions: Extensions,
     headers: Headers,
-33
+}
-34
 /// A Request URI
 #[derive(Debug, Clone)]
 pub struct Uri {
     as_string: String,
     parsed: ParsedUri,
-40
+}

↧ Expand context

-41
 #[derive(Debug, Clone)]
 enum ParsedUri {
     H0(http_02x::Uri),
     H1(http_1x::Uri),
-46
+}
-47
 impl ParsedUri {
     fn path_and_query(&self) -> &str {
         match &self {
             ParsedUri::H0(u) => u.path_and_query().map(|pq| pq.as_str()).unwrap_or(""),
             ParsedUri::H1(u) => u.path_and_query().map(|pq| pq.as_str()).unwrap_or(""),
-53
+        }
-54
+    }
-55
     fn path(&self) -> &str {
         match &self {
             ParsedUri::H0(u) => u.path(),
             ParsedUri::H1(u) => u.path(),
-60
+        }

@@ -184,184 +328,338 @@

↥ Expand context

     fn try_into(self) -> Result<http_02x::Request<B>, Self::Error> {
         self.try_into_http02x()
-186
+    }
-187
+}
-188
 #[cfg(feature = "http-1x")]
 impl From<http_1x::Uri> for Uri {
     fn from(value: http_1x::Uri) -> Self {
         Uri::from_http1x_uri(value)
-193
+    }
-194
+}
-195
 #[cfg(feature = "http-1x")]
 impl<B> TryInto<http_1x::Request<B>> for Request<B> {
     type Error = HttpError;
-199
     fn try_into(self) -> Result<http_1x::Request<B>, Self::Error> {
         self.try_into_http1x()
-202
+    }
-203
+}

-204
 impl<B> Request<B> {
     /// Converts this request into an http 0.x request.
     ///
     /// Depending on the internal storage type, this operation may be free or it may have an internal
     /// cost.
     #[cfg(feature = "http-02x")]
     pub fn try_into_http02x(self) -> Result<http_02x::Request<B>, HttpError> {
         let mut req = http_02x::Request::builder()
             .uri(self.uri.into_h0())
             .method(self.method)
             .method(
                 http_02x::Method::from_bytes(self.method.as_str().as_bytes())
                     .expect("valid method"),
-+
+            )
             .body(self.body)
             .expect("known valid");
         *req.headers_mut() = self.headers.http0_headermap();
         *req.extensions_mut() = self.extensions.try_into()?;
         Ok(req)
-223
+    }
-224
     /// Converts this request into an http 1.x request.
     ///
     /// Depending on the internal storage type, this operation may be free or it may have an internal
     /// cost.
     #[cfg(feature = "http-1x")]
     pub fn try_into_http1x(self) -> Result<http_1x::Request<B>, HttpError> {
         let mut req = http_1x::Request::builder()
             .uri(self.uri.as_string)
             .method(self.method.as_str())
             .method(self.method)
             .body(self.body)
             .expect("known valid");
         *req.headers_mut() = self.headers.http1_headermap();
         *req.extensions_mut() = self.extensions.try_into()?;
         Ok(req)
-239
+    }
-240
     /// Update the body of this request to be a new body.
     pub fn map<U>(self, f: impl Fn(B) -> U) -> Request<U> {
         Request {
             body: f(self.body),
             uri: self.uri,
             method: self.method,
             extensions: self.extensions,
             headers: self.headers,
-249
+        }
-250
+    }
-251
     /// Returns a GET request with no URI
     pub fn new(body: B) -> Self {
         Self {
             body,
             uri: Uri::from_http0x_uri(http_02x::Uri::from_static("/")),
             method: http_02x::Method::GET,
             method: http_1x::Method::GET,
             extensions: Default::default(),
             headers: Default::default(),
-260
+        }
-261
+    }
-262
     /// Convert this request into its parts.
     pub fn into_parts(self) -> RequestParts<B> {
         RequestParts {
             uri: self.uri,
             headers: self.headers,
             body: self.body,
-269
+        }
-270
+    }
-271
     /// Returns a reference to the header map
     pub fn headers(&self) -> &Headers {
         &self.headers
-275
+    }
-276
     /// Returns a mutable reference to the header map
     pub fn headers_mut(&mut self) -> &mut Headers {
         &mut self.headers
-280
+    }
-281
     /// Returns the body associated with the request
     pub fn body(&self) -> &B {
         &self.body
-285
+    }
-286
     /// Returns a mutable reference to the body
     pub fn body_mut(&mut self) -> &mut B {
         &mut self.body
-290
+    }
-291
     /// Converts this request into the request body.
     pub fn into_body(self) -> B {
         self.body
-295
+    }
-296
     /// Returns the method associated with this request
     pub fn method(&self) -> &str {
         self.method.as_str()
-300
+    }
-301
     /// Sets the HTTP method for this request
     pub fn set_method(&mut self, method: &str) -> Result<(), HttpError> {
         self.method =
             http_1x::Method::from_bytes(method.as_bytes()).map_err(HttpError::invalid_method)?;
         Ok(())
-+
+    }
-+
     /// Returns the URI associated with this request
     pub fn uri(&self) -> &str {
         &self.uri.as_string
-312
+    }
-313
     /// Returns a mutable reference the the URI of this http::Request
     pub fn uri_mut(&mut self) -> &mut Uri {
         &mut self.uri
-317
+    }
-318

↧ Expand context

     /// Sets the URI of this request
     pub fn set_uri<U>(&mut self, uri: U) -> Result<(), U::Error>
     where
         U: TryInto<Uri>,
-323
+    {
         let uri = uri.try_into()?;
         self.uri = uri;
         Ok(())
-327
+    }
-328
     /// Adds an extension to the request extensions
     pub fn add_extension<T: Send + Sync + Clone + 'static>(&mut self, extension: T) {
         self.extensions.insert(extension.clone());
-332
+    }
-333
+}
-334
 impl Request<SdkBody> {
     /// Attempts to clone this request
     ///
     /// On clone, any extensions will be cleared.

@@ -340,350 +417,428 @@

↥ Expand context

-350
+    }
-351
     /// Replaces this request's body with [`SdkBody::taken()`]
     pub fn take_body(&mut self) -> SdkBody {
         std::mem::replace(self.body_mut(), SdkBody::taken())
-355
+    }
-356
     /// Create a GET request to `/` with an empty body
     pub fn empty() -> Self {
         Self::new(SdkBody::empty())
-360
+    }
-361
     /// Creates a GET request to `uri` with an empty body
     pub fn get(uri: impl AsRef<str>) -> Result<Self, HttpError> {
         let mut req = Self::new(SdkBody::empty());
         req.set_uri(uri.as_ref())?;
         Ok(req)
-367
+    }
-368
+}
-369

 #[cfg(feature = "http-02x")]
 impl<B> TryFrom<http_02x::Request<B>> for Request<B> {
     type Error = HttpError;
-373
     fn try_from(value: http_02x::Request<B>) -> Result<Self, Self::Error> {
         let (parts, body) = value.into_parts();
         let headers = Headers::try_from(parts.headers)?;
         Ok(Self {
             body,
             uri: parts.uri.into(),
             method: parts.method,
             method: http_1x::Method::from_bytes(parts.method.as_str().as_bytes())
                 .expect("valid method"),
             extensions: parts.extensions.into(),
             headers,
         })
-385
+    }
-386
+}
-387
 #[cfg(feature = "http-1x")]
 impl<B> TryFrom<http_1x::Request<B>> for Request<B> {
     type Error = HttpError;
-391
     fn try_from(value: http_1x::Request<B>) -> Result<Self, Self::Error> {
         let (parts, body) = value.into_parts();
         let headers = Headers::try_from(parts.headers)?;
         Ok(Self {
             body,
             uri: Uri::from_http1x_uri(parts.uri),
             method: http_02x::Method::from_bytes(parts.method.as_str().as_bytes()).expect("valid"),
             method: parts.method,
             extensions: parts.extensions.into(),
             headers,
         })
-402
+    }
-403
+}
-404
 #[cfg(all(test, feature = "http-02x", feature = "http-1x"))]
 mod test {
     use aws_smithy_types::body::SdkBody;
     use http_02x::header::{AUTHORIZATION, CONTENT_LENGTH};

↧ Expand context

-409
     #[test]
     fn non_ascii_requests() {
         let request = http_02x::Request::builder()
             .header("k", "😹")
             .body(SdkBody::empty())
             .unwrap();
         let request: super::Request = request
             .try_into()
             .expect("failed to convert a non-string header");
         assert_eq!(request.headers().get("k"), Some("😹"))
-420
+    }
-421
     #[test]
     fn request_can_be_created() {
         let req = http_02x::Request::builder()
             .uri("http://foo.com")
             .body(SdkBody::from("hello"))
             .unwrap();
         let mut req = super::Request::try_from(req).unwrap();

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/Cargo.toml

@@ -1,1 +125,129 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-runtime"
 version = "1.10.3"
 version = "1.10.4"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]
 description = "The new smithy runtime crate"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [package.metadata.smithy-rs-release-tooling]
 stable = true
 [package.metadata.cargo-udeps.ignore]
 normal = ["aws-smithy-http"]
-21
 [features]
 client = ["aws-smithy-runtime-api/client", "aws-smithy-types/http-body-1-x"]
 http-auth = ["aws-smithy-runtime-api/http-auth"]
 connector-hyper-0-14-x = ["dep:aws-smithy-http-client", "aws-smithy-http-client?/hyper-014"]
 tls-rustls = ["dep:aws-smithy-http-client", "aws-smithy-http-client?/legacy-rustls-ring", "connector-hyper-0-14-x"]
 default-https-client = ["dep:aws-smithy-http-client", "aws-smithy-http-client?/rustls-aws-lc"]
 rt-tokio = ["tokio/rt"]
 test-util = ["aws-smithy-runtime-api/test-util", "dep:tracing-subscriber", "aws-smithy-http-client/test-util", "legacy-test-util"]
 legacy-test-util = ["aws-smithy-runtime-api/test-util", "dep:tracing-subscriber", "aws-smithy-http-client/test-util", "connector-hyper-0-14-x", "aws-smithy-http-client/legacy-test-util"]
 wire-mock = ["legacy-test-util", "aws-smithy-http-client/wire-mock"]
-32
 [dependencies]
 bytes = "1.11.1"
 fastrand = "2.3.0"
 http-body-util = "0.1.3"
 pin-project-lite = "0.2.14"
 pin-utils = "0.1.0"
 tracing = "0.1.44"
-40
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.14"
-44
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.63.6"
-48
 [dependencies.aws-smithy-observability]
 path = "../aws-smithy-observability"
 version = "0.2.6"
-52
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 version = "1.11.6"
 version = "1.11.7"
-+
 [dependencies.aws-smithy-schema]
 path = "../aws-smithy-schema"
 version = "1.0.0"
-60
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-0-4-x"]
 version = "1.4.7"
-65
 [dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 optional = true
 version = "1.1.12"
-70
 [dependencies.http-02x]
 package = "http"
 version = "0.2.12"
-74
 [dependencies.http-1x]
 package = "http"
 version = "1.3.1"
-78
 [dependencies.http-body-04x]
 package = "http-body"
 version = "0.4.6"
-82
 [dependencies.http-body-1x]
 package = "http-body"
 version = "1.0.1"
-86
 [dependencies.tokio]
 version = "1.49.0"
 features = []
-90
 [dependencies.tracing-subscriber]
 version = "0.3.22"
 optional = true
 features = ["env-filter", "fmt", "json"]
-95
 [dev-dependencies]
 approx = "0.5.1"
 fastrand = "2.3.0"
 futures-util = "0.3.29"
 pretty_assertions = "1.4.0"
 tracing-test = "0.2.1"
-102
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["rt-tokio", "test-util"]
 version = "1.2.14"
-107
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.11.6"
 version = "1.11.7"
-112
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["test-util"]
 version = "1.4.7"
-117
 [dev-dependencies.tokio]
 version = "1.49.0"
 features = ["macros", "rt", "rt-multi-thread", "test-util", "full"]
-121

↧ Expand context

 [dev-dependencies.tracing-subscriber]
 version = "0.3.22"
 features = ["env-filter"]
-125
 [dev-dependencies.hyper_0_14]
 package = "hyper"
 version = "0.14.27"
 features = ["client", "server", "tcp", "http1", "http2"]

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/src/client/orchestrator.rs

@@ -409,409 +480,480 @@

↥ Expand context

             builder.set_connect_timeout(timeout_config.connect_timeout());
             builder.set_read_timeout(timeout_config.read_timeout());
             builder.build()
         };
         let connector = http_client.http_connector(&settings, runtime_components);
         let response_future = MaybeUploadThroughputCheckFuture::new(
             cfg,
             runtime_components,
             connector.call(request),
         );
         response_future.await.map_err(OrchestratorError::connector)
     });
     trace!(response = ?response, "received response from service");
     ctx.set_response(response);
     ctx.enter_before_deserialization_phase();
-424
     run_interceptors!(halt_on_err: {
         read_after_transmit(ctx, runtime_components, cfg);
         modify_before_deserialization(ctx, runtime_components, cfg);
         read_before_deserialization(ctx, runtime_components, cfg);

     });
-430
     ctx.enter_deserialization_phase();
     let output_or_error = async {
         let response = ctx.response_mut().expect("set during transmit");
         let response_deserializer = cfg
             .load::<SharedResponseDeserializer>()
             .expect("a request deserializer must be in the config bag");
         let maybe_deserialized = {
             let _span = debug_span!("deserialize_streaming").entered();
             response_deserializer.deserialize_streaming(response)
             response_deserializer.deserialize_streaming_with_config(response, cfg)
         };
         match maybe_deserialized {
             Some(output_or_error) => output_or_error,
             None => read_body(response)
                 .instrument(debug_span!("read_body"))
                 .await
                 .map_err(OrchestratorError::response)
                 .and_then(|_| {
                     let _span = debug_span!("deserialize_nonstreaming").entered();
                     log_response_body(response, cfg);
                     response_deserializer.deserialize_nonstreaming(response)
                     response_deserializer.deserialize_nonstreaming_with_config(response, cfg)
                 }),
-452
+        }
-453
+    }
     .instrument(debug_span!("deserialization"))
     .await;
     trace!(output_or_error = ?output_or_error);
     ctx.set_output_or_error(output_or_error);
-458
     ctx.enter_after_deserialization_phase();
     run_interceptors!(halt_on_err: read_after_deserialization(ctx, runtime_components, cfg));

↧ Expand context

-461
+}
-462
 async fn finally_attempt(
     ctx: &mut InterceptorContext,
     cfg: &mut ConfigBag,
     runtime_components: &RuntimeComponents,
 ) {
     run_interceptors!(continue_on_err: {
         modify_before_attempt_completion(ctx, runtime_components, cfg);
         read_after_attempt(ctx, runtime_components, cfg);
     });
-472
+}
-473
 #[instrument(skip_all, level = "debug")]
 async fn finally_op(
     ctx: &mut InterceptorContext,
     cfg: &mut ConfigBag,
     runtime_components: &RuntimeComponents,
 ) {
     run_interceptors!(continue_on_err: {

     trace!("orchestrating endpoint resolution");
-78
     let params = cfg
         .get_mut_from_interceptor_state::<EndpointResolverParams>()
         .expect("endpoint resolver params must be set in the interceptor state");
     params.set_property(identity);
-83
     let endpoint_resolver = runtime_components.endpoint_resolver();
-85
     endpoint_resolver.finalize_params(params)?;
-87
     tracing::debug!(endpoint_params = ?params, "resolving endpoint");
     let endpoint = endpoint_resolver.resolve_endpoint(params).await?;
-90
     apply_endpoint(&endpoint, ctx, cfg)?;
-92
     // Make the endpoint config available to interceptors
     cfg.interceptor_state().store_put(endpoint);
     Ok(())
-96
+}

-97
 pub(super) fn apply_endpoint(
     endpoint: &Endpoint,
     ctx: &mut InterceptorContext,
     cfg: &ConfigBag,
 ) -> Result<(), BoxError> {
     let endpoint_prefix = cfg.load::<EndpointPrefix>();
     tracing::debug!(endpoint_prefix = ?endpoint_prefix, "will apply endpoint {:?}", endpoint);
     let request = ctx.request_mut().expect("set during serialization");
-106
     apply_endpoint_to_request(request, endpoint, endpoint_prefix)
     // If a schema-driven protocol is in use, delegate endpoint application to it.
     if let Some(protocol) = cfg.load::<aws_smithy_schema::protocol::SharedClientProtocol>() {
         protocol
             .update_endpoint(request, endpoint, cfg)
             .map_err(BoxError::from)?;
     } else {
         apply_endpoint_to_request(request, endpoint, endpoint_prefix)?;
-+
+    }
-+
     Ok(())
-117
+}
-118
 fn apply_endpoint_to_request(
     request: &mut HttpRequest,
     endpoint: &Endpoint,
     endpoint_prefix: Option<&EndpointPrefix>,
 ) -> Result<(), BoxError> {
     let endpoint_url = match endpoint_prefix {
         None => Cow::Borrowed(endpoint.url()),
         Some(prefix) => {

             let parsed = endpoint.url().parse::<Uri>()?;
             let scheme = parsed.scheme_str().unwrap_or_default();
             let prefix = prefix.as_str();
             let authority = parsed
                 .authority()
                 .map(|auth| auth.as_str())
                 .unwrap_or_default();
             let path_and_query = parsed
                 .path_and_query()
                 .map(PathAndQuery::as_str)
                 .unwrap_or_default();
             Cow::Owned(format!("{scheme}://{prefix}{authority}{path_and_query}"))
-139
+        }
     };
-141
     request
         .uri_mut()
         .set_endpoint(&endpoint_url)
         .map_err(|err| {
             ResolveEndpointError::message(format!(

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/codec/serializer.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/lib.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/protocol/aws_json_rpc.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/protocol/aws_rest_json_1.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/src/protocol/mod.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-mocks/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-protocol-test/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/ser_de.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/http/error.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/http/request.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/src/client/orchestrator.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/src/client/orchestrator/endpoints.rs