fix: Add AsRef<str> impl for unnamed enums

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ClientEnumGenerator.kt

@@ -84,9 +84,9 @@ data class InfallibleEnumType(
         writable {
             rustTemplate(
                 """
-                impl<T> #{From}<T> for ${context.enumName} where T: #{AsRef}<str> {
-                    fn from(s: T) -> Self {
-                        ${context.enumName}(s.as_ref().to_owned())
+                impl #{From}<&str> for ${context.enumName} {
+                    fn from(s: &str) -> Self {
+                        ${context.enumName}(s.to_owned())
                     }
                 }
                 """,

codegen-client/src/test/kotlin/software/amazon/smithy/rust/codegen/client/smithy/generators/ClientEnumGeneratorTest.kt

@@ -72,6 +72,40 @@ class ClientEnumGeneratorTest {
         expectMatchExpressionCompiles(modelV2, "test#SomeEnum", variant3AsVariant3)
     }
 
+    @Test
+    fun `unnamed enums implement AsRef`() {
+        val model =
+            """
+            namespace test
+            @enum([
+                { value: "Foo" },
+                { value: "Bar" },
+            ])
+            string SomeEnum
+            """.asSmithyModel()
+
+        val shape = model.lookup<StringShape>("test#SomeEnum")
+        val context = testClientCodegenContext(model)
+        val project = TestWorkspace.testProject(context.symbolProvider)
+        project.moduleFor(shape) {
+            ClientEnumGenerator(context, shape, emptyList()).render(this)
+            unitTest(
+                "unnamed_enums_implement_asref",
+                """
+                let foo = SomeEnum::from("Foo");
+                let foo_ref: &str = foo.as_ref();
+                assert_eq!(foo_ref, "Foo");
+
+                fn takes_asref(s: impl AsRef<str>) -> String {
+                    s.as_ref().to_owned()
+                }
+                assert_eq!(takes_asref(SomeEnum::from("Bar")), "Bar");
+                """,
+            )
+        }
+        project.compileAndTest()
+    }
+
     @Test
     fun `impl debug for non-sensitive enum should implement the derived debug trait`() {
         val model =

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

@@ -274,6 +274,16 @@ open class EnumGenerator(
                     rust("&self.0")
                 },
         )
+        rustTemplate(
+            """
+            impl #{AsRef}<str> for ${context.enumName} {
+                fn as_ref(&self) -> &str {
+                    self.as_str()
+                }
+            }
+            """,
+            *preludeScope,
+        )
         // impl From<str> for Blah { ... }
         enumType.implFromForStrForUnnamedEnum(context)(this)
         // impl FromStr for Blah { ... }

codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/EnumGeneratorTest.kt

@@ -235,6 +235,40 @@ class EnumGeneratorTest {
             project.compileAndTest()
         }
 
+        @Test
+        fun `unnamed enums implement AsRef`() {
+            val model =
+                """
+                namespace test
+                @enum([
+                    { value: "Foo" },
+                    { value: "Bar" },
+                ])
+                string SomeEnum
+                """.asSmithyModel()
+
+            val shape = model.lookup<StringShape>("test#SomeEnum")
+            val provider = testSymbolProvider(model)
+            val project = TestWorkspace.testProject(provider)
+            project.moduleFor(shape) {
+                renderEnum(model, provider, shape)
+                unitTest(
+                    "unnamed_enums_implement_asref",
+                    """
+                    let foo = SomeEnum::from("Foo");
+                    let foo_ref: &str = foo.as_ref();
+                    assert_eq!(foo_ref, "Foo");
+
+                    fn takes_asref(s: impl AsRef<str>) -> String {
+                        s.as_ref().to_owned()
+                    }
+                    assert_eq!(takes_asref(SomeEnum::from("Bar")), "Bar");
+                    """,
+                )
+            }
+            project.compileAndTest()
+        }
+
         @Test
         fun `it generates unnamed enums`() {
             val model =