Honor exact C# names over back-compat naming

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/RestClientProvider.cs

@@ -1116,6 +1116,11 @@ private static bool TryGetSpecialHeaderParam(InputParameter inputParameter, [Not
 
         private static void UpdateParameterNameWithBackCompat(InputParameter inputParameter, string proposedName, TypeProvider backCompatProvider, InputServiceMethod? serviceMethod = null)
         {
+            if (inputParameter.IsExactName)
+            {
+                return;
+            }
+
             // Look up the parameter's original (spec) name in the previous contract.
             // When a service method is supplied, scope the search to methods whose name matches
             // the current service method (allowing for sync/async pairing) so that a common

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/RestClientProviderTests.cs

@@ -697,6 +697,31 @@ public async Task ParameterNamePreservedFromLastContractView()
                 "When 'oldParam' is preserved, the renamed 'newParam' must not appear.");
         }
 
+        [Test]
+        public async Task ExactParameterNameTakesPrecedenceOverLastContractView()
+        {
+            var queryParam = InputFactory.QueryParameter(
+                "oldParam",
+                InputPrimitiveType.String,
+                isRequired: true,
+                isExactName: true);
+            queryParam.Update(name: "exact_param");
+
+            var operation = InputFactory.Operation("GetSomething", parameters: [queryParam]);
+            var serviceMethod = InputFactory.BasicServiceMethod("GetSomething", operation);
+            var client = InputFactory.Client("TestClient", methods: [serviceMethod]);
+
+            var generator = await MockHelpers.LoadMockGeneratorAsync(
+                clients: () => [client],
+                lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync(
+                    parameters: "Last"));
+
+            var clientProvider = generator.Object.OutputLibrary.TypeProviders.OfType<ClientProvider>().First();
+            var restClientProvider = new MockClientProvider(client, clientProvider);
+            var actual = new TypeProviderWriter(restClientProvider).Write().Content;
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), actual);
+        }
+
         [Test]
         public async Task ParameterNamePreservedFromInternalLastContractMethod()
         {

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/TestData/RestClientProviderTests/ExactParameterNameTakesPrecedenceOverLastContractView(Last)/TestClient.cs

@@ -0,0 +1,9 @@
+namespace Sample
+{
+    public partial class TestClient
+    {
+        public void GetSomething(string oldParam)
+        {
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/RestClientProviders/TestData/RestClientProviderTests/ExactParameterNameTakesPrecedenceOverLastContractView.cs

@@ -0,0 +1,22 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System.ClientModel.Primitives;
+
+namespace Sample
+{
+    public partial class TestClient
+    {
+        internal global::System.ClientModel.Primitives.PipelineMessage CreateGetSomethingRequest(string exact_param, global::System.ClientModel.Primitives.RequestOptions options)
+        {
+            global::Sample.ClientUriBuilder uri = new global::Sample.ClientUriBuilder();
+            uri.Reset(_endpoint);
+            uri.AppendQuery("oldParam", exact_param, true);
+            global::System.ClientModel.Primitives.PipelineMessage message = Pipeline.CreateMessage(uri.ToUri(), "GET", PipelineMessageClassifier200);
+            global::System.ClientModel.Primitives.PipelineRequest request = message.Request;
+            message.Apply(options);
+            return message;
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/EnumProvider.cs

@@ -95,8 +95,14 @@ private IEnumerable<string> GetCustomMemberNames()
         private protected string GetBackCompatibleName(
             string generatedName,
             IReadOnlyList<string> generatedNames,
-            IReadOnlyList<string> lastContractNames)
+            IReadOnlyList<string> lastContractNames,
+            bool isExactName = false)
         {
+            if (isExactName)
+            {
+                return generatedName;
+            }
+
             if (lastContractNames.Count == 0)
             {
                 return generatedName;

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/ExtensibleEnumProvider.cs

@@ -62,7 +62,7 @@ protected override IReadOnlyList<EnumTypeMember> BuildEnumValues()
                 // build the field
                 var modifiers = FieldModifiers.Private | FieldModifiers.Const;
                 // the fields for extensible enums are private and const, storing the underlying values, therefore we need to append the word `Value` to the name
-                var valueName = GetBackCompatibleName(generatedNames[i], generatedNames, lastContractNames);
+                var valueName = GetBackCompatibleName(generatedNames[i], generatedNames, lastContractNames, inputValue.IsExactName);
                 var name = $"{valueName}Value";
                 // for initializationValue, if the enum is extensible, we always need it
                 var initializationValue = Literal(inputValue.Value);

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/FixedEnumProvider.cs

@@ -86,7 +86,7 @@ protected override IReadOnlyList<EnumTypeMember> BuildEnumValues()
                 var inputValue = AllowedValues[i];
                 var modifiers = FieldModifiers.Public | FieldModifiers.Static;
                 // the fields for fixed enums are just its members (we use fields to represent the values in a system `enum` type), we just use the name for this field
-                var name = GetBackCompatibleName(generatedNames[i], generatedNames, lastContractNames);
+                var name = GetBackCompatibleName(generatedNames[i], generatedNames, lastContractNames, inputValue.IsExactName);
 
                 // check if the enum member was renamed in custom code
                 string? customMemberName = null;
@@ -216,7 +216,7 @@ private HashSet<string> GetCustomMemberLastContractNames(IReadOnlyList<FieldProv
                 if (customOriginalNames.Contains(generatedNames[i]))
                 {
                     customMemberLastContractNames.Add(
-                        GetBackCompatibleName(generatedNames[i], generatedNames, lastContractNames));
+                        GetBackCompatibleName(generatedNames[i], generatedNames, lastContractNames, AllowedValues[i].IsExactName));
                 }
             }
 

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/ModelFactoryProvider.cs

@@ -146,7 +146,8 @@ protected internal sealed override IReadOnlyList<MethodProvider> BuildMethodsFor
                 {
                     if (currentMethodSignature.Name.Equals(previousMethod.Signature.Name))
                     {
-                        if (MethodSignatureHelper.HaveSameParametersInSameOrder(currentMethodSignature, previousMethod.Signature))
+                        if (MethodSignatureHelper.HaveSameParametersInSameOrder(currentMethodSignature, previousMethod.Signature)
+                            || HasMatchingExactParameterNames(currentMethodSignature, previousMethod.Signature))
                         {
                             foundCompatibleOverload = true;
                             break;
@@ -219,6 +220,25 @@ protected internal sealed override IReadOnlyList<MethodProvider> BuildMethodsFor
             return [.. factoryMethods];
         }
 
+        private static bool HasMatchingExactParameterNames(MethodSignature current, MethodSignature previous)
+        {
+            if (!MethodSignature.MethodSignatureComparer.Equals(current, previous))
+            {
+                return false;
+            }
+
+            for (int i = 0; i < current.Parameters.Count; i++)
+            {
+                if (current.Parameters[i].Name != previous.Parameters[i].Name &&
+                    !current.Parameters[i].IsExactName)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         internal static IReadOnlyList<string> GetUnavailableSignatureTypes(MethodSignature signature)
         {
             var unavailableTypes = new HashSet<string>(StringComparer.Ordinal);

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/ModelProvider.cs

@@ -958,7 +958,8 @@ private void RestorePreviousConstructorParameterNames(
                 for (int i = 0; i < restoredParameters.Count; i++)
                 {
                     var restoredName = previousParameters[i].Name;
-                    if (string.Equals(restoredParameters[i].Name, restoredName, StringComparison.Ordinal))
+                    if (string.Equals(restoredParameters[i].Name, restoredName, StringComparison.Ordinal)
+                        || restoredParameters[i].IsExactName)
                     {
                         continue;
                     }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/ParameterProvider.cs

@@ -57,6 +57,11 @@ public sealed class ParameterProvider : IEquatable<ParameterProvider>
         /// </summary>
         public InputParameter? InputParameter { get; private set; }
 
+        /// <summary>
+        /// Indicates that the name of this parameter was explicitly configured and must be used verbatim.
+        /// </summary>
+        internal bool IsExactName { get; private init; }
+
         /// <summary>
         /// Creates a <see cref="ParameterProvider"/> from an <see cref="InputParameter"/>.
         /// </summary>
@@ -96,6 +101,7 @@ public ParameterProvider(InputParameter inputParameter)
             WireInfo = new WireInformation(CodeModelGenerator.Instance.TypeFactory.GetSerializationFormat(inputParameter.Type), inputParameter.SerializedName);
             Location = inputParameter.ToParameterLocation();
             Attributes = [];
+            IsExactName = inputParameter.IsExactName;
         }
 
         public ParameterProvider(
@@ -134,6 +140,7 @@ public ParameterProvider(
             WireInfo = wireInfo ?? new WireInformation(SerializationFormat.Default, name);
             Location = location ?? ParameterLocation.Unknown;
             InputParameter = inputParameter;
+            IsExactName = inputParameter?.IsExactName == true || property?.InputProperty?.IsExactName == true;
         }
 
         private ParameterProvider? _inputParameter;
@@ -164,7 +171,8 @@ private ParameterProvider BuildInputVariant()
             {
                 _asVariable = _asVariable,
                 SpreadSource = SpreadSource,
-                InputParameter = InputParameter
+                InputParameter = InputParameter,
+                IsExactName = IsExactName
             };
         }
 
@@ -300,6 +308,7 @@ internal ParameterProvider WithRef()
                 validation: Validation)
             {
                 _asVariable = _asVariable,
+                IsExactName = IsExactName,
             };
         }
 

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Utilities/BackCompatHelper.cs

@@ -187,6 +187,11 @@ public static void RestorePreviousParameterNames(
                 for (int i = 0; i < currentParameters.Count; i++)
                 {
                     var parameter = currentParameters[i];
+                    if (parameter.IsExactName)
+                    {
+                        continue;
+                    }
+
                     string? preservedName = null;
 
                     var inputParameter = parameter.InputParameter;

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/EnumProviders/EnumProviderTests.cs

@@ -1310,6 +1310,28 @@ await MockHelpers.LoadMockGeneratorAsync(
             Assert.AreEqual("CallbackUrl", enumProvider.EnumValues.Single().Name);
         }
 
+        // An explicitly configured (exact) member name must win over the name published in the last
+        // contract, otherwise the naming override would be silently reverted by back compatibility.
+        [TestCase(false, "Fixed")]
+        [TestCase(true, "Extensible")]
+        public async Task BuildEnumType_ExactValueNameTakesPrecedenceOverLastContract(bool isExtensible, string testData)
+        {
+            await MockHelpers.LoadMockGeneratorAsync(
+                createCSharpTypeCore: (inputType) => typeof(string),
+                lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync(parameters: testData));
+            var enumValues = new List<InputEnumTypeValue>();
+            var input = InputFactory.Enum(
+                "mockInputEnum",
+                InputPrimitiveType.String,
+                enumValues,
+                isExtensible: isExtensible);
+            enumValues.Add(InputFactory.EnumMember.String("api_key", "value", input, isExactName: true));
+
+            var enumProvider = EnumProvider.Create(input);
+
+            Assert.AreEqual("api_key", enumProvider.EnumValues.Single().Name);
+        }
+
         private static void ValidateGetHashCodeMethod(EnumProvider enumType)
         {
             var getHashCodeMethod = enumType.Methods.Single(m => m.Signature.Name == "GetHashCode");

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/EnumProviders/TestData/EnumProviderTests/BuildEnumType_ExactValueNameTakesPrecedenceOverLastContract(Extensible)/MockInputEnum.cs

@@ -0,0 +1,7 @@
+namespace Sample.Models
+{
+    public readonly partial struct MockInputEnum
+    {
+        public static MockInputEnum ApiKey { get; }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/EnumProviders/TestData/EnumProviderTests/BuildEnumType_ExactValueNameTakesPrecedenceOverLastContract(Fixed)/MockInputEnum.cs

@@ -0,0 +1,7 @@
+namespace Sample.Models
+{
+    public enum MockInputEnum
+    {
+        ApiKey
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/ModelFactories/ModelFactoryProviderTests.cs

@@ -570,6 +570,23 @@ public async Task BackCompatibility_OnlyParamNameChanged()
             Assert.AreEqual("oldModelProp", docParams[1].Parameter.Name);
         }
 
+        [Test]
+        public async Task BackCompatibility_ExactPropertyNameTakesPrecedence()
+        {
+            var inputModels = GetTestModels(isStringPropExact: true);
+            _instance = (await MockHelpers.LoadMockGeneratorAsync(
+                inputNamespaceName: "Sample.Namespace",
+                inputModelTypes: inputModels,
+                lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync(
+                    parameters: "Last"))).Object;
+
+            var modelFactory = _instance!.OutputLibrary.ModelFactory.Value;
+            modelFactory.ProcessTypeForBackCompatibility();
+
+            var actual = new TypeProviderWriter(modelFactory).Write().Content;
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), actual);
+        }
+
         // Validates that when ALL parameters in a factory method are renamed in the previous
         // contract, every preserved name is propagated to the current method. This complements
         // BackCompatibility_OnlyParamNameChanged which exercises a partial rename.
@@ -1331,12 +1348,12 @@ public async Task BackCompatibility_BackCompatMethodCanBeMutatedByVisitor()
             Assert.IsNotNull(renamed, "The visitor's rename of the back-compat method was not applied.");
         }
 
-        private static InputModelType[] GetTestModels()
+        private static InputModelType[] GetTestModels(bool isStringPropExact = false)
         {
             InputType additionalPropertiesUnknown = InputPrimitiveType.Any;
             InputModelProperty[] properties =
             [
-                InputFactory.Property("StringProp", InputPrimitiveType.String),
+                InputFactory.Property("StringProp", InputPrimitiveType.String, isExactName: isStringPropExact),
                 InputFactory.Property("ModelProp", InputFactory.Model("Thing")),
                 InputFactory.Property("ListProp", InputFactory.Array(InputPrimitiveType.String)),
                 InputFactory.Property("DictProp", InputFactory.Dictionary(InputPrimitiveType.String, InputPrimitiveType.String)),

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/ModelFactories/TestData/ModelFactoryProviderTests/BackCompatibility_ExactPropertyNameTakesPrecedence(Last)/SampleNamespaceModelFactory.cs

@@ -0,0 +1,24 @@
+using SampleTypeSpec;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Sample.Models;
+
+namespace Sample.Namespace
+{
+    public static partial class SampleNamespaceModelFactory
+    {
+        public static PublicModel1 PublicModel1(
+            string oldStringProp = default,
+            Thing oldModelProp = default,
+            IEnumerable<string> listProp = default,
+            IDictionary<string, string> dictProp = default)
+        { return null; }
+    }
+}
+
+namespace Sample.Models
+{
+    public partial class Thing
+    { }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/ModelFactories/TestData/ModelFactoryProviderTests/BackCompatibility_ExactPropertyNameTakesPrecedence.cs

@@ -0,0 +1,61 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Sample.Models;
+
+namespace Sample.Namespace
+{
+    public static partial class SampleNamespaceModelFactory
+    {
+        public static global::Sample.Models.PublicModel1 PublicModel1(string stringProp = default, global::Sample.Models.Thing oldModelProp = default, global::System.Collections.Generic.IEnumerable<string> listProp = default, global::System.Collections.Generic.IDictionary<string, string> dictProp = default)
+        {
+            listProp ??= new global::Sample.Namespace.ChangeTrackingList<string>();
+            dictProp ??= new global::Sample.Namespace.ChangeTrackingDictionary<string, string>();
+
+            return new global::Sample.Models.PublicModel1(stringProp, oldModelProp, listProp.ToList(), dictProp, additionalBinaryDataProperties: null);
+        }
+
+        public static global::Sample.Models.PublicModel2 PublicModel2(string stringProp = default, global::Sample.Models.Thing modelProp = default, global::System.Collections.Generic.IEnumerable<string> listProp = default, global::System.Collections.Generic.IDictionary<string, string> dictProp = default)
+        {
+            listProp ??= new global::Sample.Namespace.ChangeTrackingList<string>();
+            dictProp ??= new global::Sample.Namespace.ChangeTrackingDictionary<string, string>();
+
+            return new global::Sample.Models.PublicModel2(stringProp, modelProp, listProp.ToList(), dictProp, additionalBinaryDataProperties: null);
+        }
+
+        public static global::Sample.Models.DerivedModel DerivedModel(string stringProp = default, global::Sample.Models.Thing modelProp = default, global::System.Collections.Generic.IEnumerable<string> listProp = default, global::System.Collections.Generic.IDictionary<string, string> dictProp = default)
+        {
+            listProp ??= new global::Sample.Namespace.ChangeTrackingList<string>();
+            dictProp ??= new global::Sample.Namespace.ChangeTrackingDictionary<string, string>();
+
+            return new global::Sample.Models.DerivedModel(
+                additionalBinaryDataProperties: null,
+                stringProp,
+                modelProp,
+                listProp.ToList(),
+                dictProp,
+                default);
+        }
+
+        public static global::Sample.Models.BaseModel BaseModel(string stringProp = default, global::Sample.Models.Thing modelProp = default, global::System.Collections.Generic.IEnumerable<string> listProp = default, global::System.Collections.Generic.IDictionary<string, string> dictProp = default)
+        {
+            listProp ??= new global::Sample.Namespace.ChangeTrackingList<string>();
+            dictProp ??= new global::Sample.Namespace.ChangeTrackingDictionary<string, string>();
+
+            return new global::Sample.Models.BaseModel(stringProp, modelProp, listProp.ToList(), dictProp, additionalBinaryDataProperties: null);
+        }
+
+        public static global::Sample.Models.ModelWithUnknownAdditionalProperties ModelWithUnknownAdditionalProperties(string stringProp = default, global::Sample.Models.Thing modelProp = default, global::System.Collections.Generic.IEnumerable<string> listProp = default, global::System.Collections.Generic.IDictionary<string, string> dictProp = default, global::System.Collections.Generic.IDictionary<string, global::System.BinaryData> additionalProperties = default)
+        {
+            listProp ??= new global::Sample.Namespace.ChangeTrackingList<string>();
+            dictProp ??= new global::Sample.Namespace.ChangeTrackingDictionary<string, string>();
+            additionalProperties ??= new global::Sample.Namespace.ChangeTrackingDictionary<string, global::System.BinaryData>();
+
+            return new global::Sample.Models.ModelWithUnknownAdditionalProperties(stringProp, modelProp, listProp.ToList(), dictProp, additionalProperties);
+        }
+    }
+}