Ideas for making compilation faster

[thomas-k-cameron]

I have some ideas for making compilation faster.

Crate Per Service

You should be able to make it faster by chopping generated code into multiple crates.

rustc does something similar
https://rustc-dev-guide.rust-lang.org/compiler-src.html#big-picture

Compile time. By breaking the compiler into multiple crates, we can take better advantage of incremental/parallel compilation using cargo.

I suggest having a single crate for each service and maybe feature gate for each of them.
API on fluent-builder can tell users to enable the feature when it's not.

Like this.

impl super::Client {
    #[cfg!(not(feature = "create_launch_template"))]
    /// regular function with the documents
    pub fn create_launch_template(
        &self,
    ) -> crate::operation::create_launch_template::builders::CreateLaunchTemplateFluentBuilder {
        crate::operation::create_launch_template::builders::CreateLaunchTemplateFluentBuilder::new(
            self.handle.clone(),
        )
    }

    #[cfg!(feature = "create_launch_template")]
    /// Please enable feature `create_launch_template` to enable this feature.
    pub fn create_launch_template(
        &self,
    ) -> crate::operation::create_launch_template::builders::CreateLaunchTemplateFluentBuilder {
        panic!("Please enable feature `create_launch_template`")
    }
}

Replacing smithy specific json serialization/de-serialization code with serde/serde_json crate.

I noticed there are lots of code for de-serializing json data that come from AWS.
I think you can use serde crate for de-serialization like this.

// current implementation
pub fn serialize_structure_crate_model_data_retrieval_rule(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DataRetrievalRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_33) = &input.strategy {
        object.key("Strategy").string(var_33.as_str());
    }
    if let Some(var_34) = &input.bytes_per_hour {
        object.key("BytesPerHour").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_34).into()),
        );
    }
    Ok(())
}

// new
#[derive(Deserialize)]
struct RawCreateModelDataRetrivalRuleOutput {
    #[serde(rename = "Strategy")]
    strategy: String,
    #[serde(rename = "BytesPerHour")]
    bytes_per_hour: i64,
}

Furthremore, I think you could have something like aws_sdk_s3_prelude that keeps data types that are used by multiple services.

Considerations

• compile time and runtime performance might improve (we need to benchmark it).
• Less code-gen logics to maintain
• It seems like parameter names of AWS-CLI is same as the original key name of the http body; We might be able to make it compatible with other library.

[82marbag]

I believe both are already addressed in https://github.com/awslabs/smithy-rs/blob/5b260e5db94830bc8fb75a22a9f1957b6fd4d838/design/src/faq.md

Having said that, things might change soon, as we've been discussing both points already

[thomas-k-cameron]

I completely missed that part.

Thank you for letting me know!