Narrow setter/getter rename to meta members only

The previous approach renamed every member that the symbol provider
touched, which changed `set_default`/`set_build`/`set_builder` (and the
matching getters) for any struct with those fields — a breaking change
flagged by @rcoh on review.

The duplicate-definition bug only occurs for error-struct builders,
where `ErrorGenerator` injects `set_meta` for `ErrorMetadata`. Only
rename members whose raw name is `meta` and leave every other setter
and getter at its pre-existing `set_<raw>` / `get_<raw>` name.

Rewrite the regression test to actually reproduce the original bug: it
now builds a `TestError` (an `@error` shape with a `meta` member) and
asserts `set_default` stays intact, so the earlier failure mode and the
guard against unrelated renames are both covered.

Also drop a now-unused `toSnakeCase` import in `ServerBuilderGenerator`
that surfaced after rebasing onto main.

Author: nated0g

.changelog/fix-builder-accessor-naming.md

@@ -6,4 +6,4 @@ breaking: false
 new_feature: false
 bug_fix: true
 ---
-Fix builder accessor methods to use symbol provider for naming. This resolves conflicts when struct members are renamed due to reserved words (e.g., `meta` -> `meta_value`), ensuring setter and getter methods use the correct renamed field names.
+Fix a duplicate `set_meta` definition when an error structure has a `meta` member. The generated struct field is already renamed to `meta_value`, so the builder's setter and getter now match (`set_meta_value`, `get_meta_value`, `meta_value`). Setters for other renamed members (e.g. `default`, `build`, `builder`) are unchanged.

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

@@ -139,8 +139,13 @@ class FluentClientGeneratorTest {
         clientIntegrationTest(model)
     }
 
+    // Regression test for https://github.com/smithy-lang/smithy-rs/issues/4338: an error shape
+    // with a `meta` member used to produce a duplicate `set_meta` method on the generated builder
+    // because `ErrorGenerator` injects its own `set_meta` for `ErrorMetadata`. The fix renames
+    // only `meta` members (field, setter, getter) while leaving other members like `default`
+    // untouched so we don't introduce unrelated breaking changes.
     @Test
-    fun `meta field gets renamed to meta_value with correct setter`() {
+    fun `meta field on error shape does not collide with injected set_meta`() {
         val model =
             """
             namespace com.example
@@ -152,10 +157,21 @@ class FluentClientGeneratorTest {
                 version: "1"
             }
 
-            operation TestOperation { input: TestInput }
+            operation TestOperation {
+                input: TestInput,
+                errors: [TestError]
+            }
+
             structure TestInput {
                meta: String,
-               other: String
+               other: String,
+               default: String
+            }
+
+            @error("client")
+            structure TestError {
+                meta: String,
+                message: String
             }
             """.asSmithyModel()
 
@@ -172,24 +188,40 @@ class FluentClientGeneratorTest {
                             .build();
                         let client = $moduleName::Client::from_conf(config);
 
-                        // Test the renamed field and setter
+                        // `meta` is renamed to `meta_value` for field, setter, and getter to
+                        // avoid the `ErrorMetadata` collision on error shapes.
                         let builder = client.test_operation()
                             .meta_value("test_meta")
                             .set_meta_value(Some("test_meta_2".to_string()))
-                            .other("other_value");
+                            .other("other_value")
+                            // `default` keeps `set_default` / `get_default` even though its field
+                            // is renamed to `default_value` — renaming the accessors would be an
+                            // unnecessary breaking change.
+                            .set_default(Some("default_value".to_string()));
 
-                        // Verify getter returns correct value
                         assert_eq!(*builder.get_meta_value(), Some("test_meta_2".to_string()));
                         assert_eq!(*builder.get_other(), Some("other_value".to_string()));
+                        assert_eq!(*builder.get_default(), Some("default_value".to_string()));
 
-                        // Build the input and verify field is accessible
                         let input = builder.as_input();
                         assert_eq!(*input.get_meta_value(), Some("test_meta_2".to_string()));
+
+                        // The error builder must compile without a duplicate `set_meta` — the
+                        // original bug — and `meta_value` must coexist with the injected error
+                        // metadata field.
+                        let _error = $moduleName::types::error::TestError::builder()
+                            .meta_value("user_meta")
+                            .message("boom")
+                            .meta(#{ErrorMetadata}::builder().code("TestError").build())
+                            .build();
                     }
                     """,
                     "NeverClient" to
                         CargoDependency.smithyHttpClientTestUtil(codegenContext.runtimeConfig).toType()
                             .resolve("test_util::NeverClient"),
+                    "ErrorMetadata" to
+                        CargoDependency.smithyTypes(codegenContext.runtimeConfig).toType()
+                            .resolve("error::ErrorMetadata"),
                 )
             }
         }

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

@@ -134,14 +134,32 @@ class OperationBuildError(private val runtimeConfig: RuntimeConfig) {
     }
 }
 
+// Builder setters/getters keep the raw member name in almost all cases: setter names don't
+// collide with Rust reserved words, and renaming would be a breaking change for consumers of
+// the generated SDK. The one exception is members named `meta` on error-struct builders, where
+// `ErrorGenerator` injects a `set_meta` method for `ErrorMetadata` — we fall back to the
+// symbol-provider-renamed name (`meta_value`) there to avoid a duplicate definition.
+// See https://github.com/smithy-lang/smithy-rs/issues/4338.
 fun MemberShape.setterName(symbolProvider: SymbolProvider): String {
-    val unescaped = symbolProvider.toMemberName(this).removePrefix("r##")
-    return "set_$unescaped"
+    val raw = this.memberName.toSnakeCase()
+    val name =
+        if (raw == "meta") {
+            symbolProvider.toMemberName(this).removePrefix("r##")
+        } else {
+            raw
+        }
+    return "set_$name"
 }
 
 fun MemberShape.getterName(symbolProvider: SymbolProvider): String {
-    val unescaped = symbolProvider.toMemberName(this).removePrefix("r##")
-    return "get_$unescaped"
+    val raw = this.memberName.toSnakeCase()
+    val name =
+        if (raw == "meta") {
+            symbolProvider.toMemberName(this).removePrefix("r##")
+        } else {
+            raw
+        }
+    return "get_$name"
 }
 
 class BuilderGenerator(

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerBuilderGenerator.kt

@@ -46,7 +46,6 @@ import software.amazon.smithy.rust.codegen.core.util.dq
 import software.amazon.smithy.rust.codegen.core.util.hasTrait
 import software.amazon.smithy.rust.codegen.core.util.letIf
 import software.amazon.smithy.rust.codegen.core.util.redactIfNecessary
-import software.amazon.smithy.rust.codegen.core.util.toSnakeCase
 import software.amazon.smithy.rust.codegen.server.smithy.ServerCodegenContext
 import software.amazon.smithy.rust.codegen.server.smithy.canReachConstrainedShape
 import software.amazon.smithy.rust.codegen.server.smithy.generators.protocol.ServerProtocol