Missing AsRef<str> implementation for unnamed enums

[demosdemon]

The generated code for named enums includes an AsRef<str> implementation that defers to Self::as_str.

smithy-rs/codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/EnumGenerator.kt

Lines 217 to 226 in 4b66264

	rustTemplate(
	"""
	impl #{AsRef}<str> for ${context.enumName} {
	fn as_ref(&self) -> &str {
	self.as_str()
	}
	}
	""",
	*preludeScope,
	)

Example:

impl ::std::convert::AsRef<str> for StageType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

The implementation for unnamed enums should do the same, but doesn't.

Example:

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// Targets represent instances in underlying systems, like packages, code deploy apps, etc.
#[non_exhaustive]
#[derive(
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
)]
pub struct TargetType(String);
impl TargetType {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        &self.0
    }
    /// Returns all the `&str` representations of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["BATS", "CD", "CF", "DG", "ENV", "GEN", "OS", "PKG", "VS"]
    }
}
impl ::std::str::FromStr for TargetType {
    type Err = ::std::convert::Infallible;

    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
        ::std::result::Result::Ok(TargetType::from(s))
    }
}
impl<T> ::std::convert::From<T> for TargetType
where
    T: ::std::convert::AsRef<str>,
{
    fn from(s: T) -> Self {
        TargetType(s.as_ref().to_owned())
    }
}

This causes generated clients for models that use these unnamed enums in url path or query parameters to not build due to the AsRef<str> binding here:

smithy-rs/rust-runtime/aws-smithy-http/src/query.rs

Lines 16 to 19 in 4b66264

	/// Format a given string as a query string.
	pub fn fmt_string<T: AsRef<str>>(t: T) -> String {
	utf8_percent_encode(t.as_ref(), BASE_SET).to_string()
	}

[drganjoo]

Unnamed enums already have a blanket implementation for converting from any type that implements AsRef<str>:

impl<T> From<T> for TargetType
where
    T: AsRef<str>,

If we implement AsRef<str> for TargetType, it results in a compilation error:

   conflicting implementation in crate `core`:
           impl<T> From<T> for T;

This conflict occurs because implementing AsRef<str> for TargetType would make TargetType itself eligible for our blanket implementation impl<T> From<T> for TargetType (since it would now implement AsRef<str>). This conflicts with the built-in blanket implementation in the core crate that allows converting a type into itself.

As a workaround, you can use the existing .as_str() method on unnamed enums to get a string reference when needed.