diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmModelProvider.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmModelProvider.cs index f35d4ae05f5..e28843e07ca 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmModelProvider.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmModelProvider.cs @@ -13,6 +13,7 @@ using System.Linq; using System.Runtime.CompilerServices; using System.Text.Json.Serialization; +using Microsoft.CodeAnalysis; using Microsoft.TypeSpec.Generator.ClientModel.Primitives; using Microsoft.TypeSpec.Generator.ClientModel.Snippets; using Microsoft.TypeSpec.Generator.EmitterRpc; @@ -31,6 +32,7 @@ namespace Microsoft.TypeSpec.Generator.ClientModel.Providers public class ScmModelProvider : ModelProvider { private readonly InputModelType _inputModel; + private readonly Lazy _lastContractUnknownDiscriminatorModelName; private readonly Dictionary _nullablePropertyPresence = []; // MRW and multipart serialization can add an empty constructor with an implicit base() call. @@ -77,12 +79,106 @@ protected override bool RequiresParameterlessBaseConstructor public ScmModelProvider(InputModelType inputModel) : base(inputModel) { _inputModel = inputModel; + _lastContractUnknownDiscriminatorModelName = new(BuildLastContractUnknownDiscriminatorModelName); IsDynamicModel = inputModel.IsDynamicModel; // Resolve the hierarchy only after TypeFactory has registered this provider. Eager // resolution here lets compatibility probes cache null types for recursive properties. BaseJsonPatchProperty = new(GetBaseJsonPatchProperty); } + protected override string BuildName() + { + if (!_inputModel.IsUnknownDiscriminatorModel || + _lastContractUnknownDiscriminatorModelName.Value is not { } historicalName) + { + return base.BuildName(); + } + + var generatedName = base.BuildName(); + var sourceInputModel = ScmCodeModelGenerator.Instance.SourceInputModel; + if (sourceInputModel.FindForTypeInCurrentCompilation(BuildNamespace(), historicalName) is not null) + { + return historicalName; + } + + return sourceInputModel.FindForTypeInCurrentCompilation(BuildNamespace(), generatedName) is not null + ? generatedName + : historicalName; + } + + private string? BuildLastContractUnknownDiscriminatorModelName() + { + if (_inputModel.BaseModel is not { } baseModel || + ScmCodeModelGenerator.Instance.TypeFactory.CreateModel(baseModel)?.LastContractView is not { } lastContractBase) + { + return null; + } + + var proxyAttributes = lastContractBase.Attributes + .Where(attribute => attribute.Type.Equals(typeof(PersistableModelProxyAttribute))) + .ToArray(); + if (proxyAttributes.Length != 1 || + proxyAttributes[0].Arguments.Count != 1 || + proxyAttributes[0].Arguments[0] is not TypeOfExpression { Type: var previousUnknownType } || + previousUnknownType.Namespace != BuildNamespace() || + previousUnknownType.Name == base.BuildName()) + { + return null; + } + + var previousUnknownTypeName = previousUnknownType.FullyQualifiedName; + var sourceInputModel = ScmCodeModelGenerator.Instance.SourceInputModel; + if (sourceInputModel.ApiCompatBaseline.IsTypeSuppressed(previousUnknownTypeName)) + { + ScmCodeModelGenerator.Instance.Emitter.Info( + $"Skipping back-compat unknown discriminator model name '{previousUnknownTypeName}' for '{lastContractBase.Type.Namespace}.{lastContractBase.Name}'; the type is an accepted removal in the ApiCompat baseline.", + BackCompatibilityChangeCategory.BaselineAcceptedRemovalSkipped); + return null; + } + + if (HasUnknownDiscriminatorNameCollision(previousUnknownType.Name)) + { + ScmCodeModelGenerator.Instance.Emitter.Info( + $"Skipping back-compat unknown discriminator model name '{previousUnknownTypeName}' for '{lastContractBase.Type.Namespace}.{lastContractBase.Name}'; the name is already used by another generated or custom type.", + BackCompatibilityChangeCategory.UnknownDiscriminatorModelNameSkipped); + return null; + } + + return previousUnknownType.Name; + } + + private bool HasUnknownDiscriminatorNameCollision(string name) + { + var typeFactory = ScmCodeModelGenerator.Instance.TypeFactory; + var sourceInputModel = ScmCodeModelGenerator.Instance.SourceInputModel; + var generatedName = base.BuildName(); + var customType = sourceInputModel.FindForTypeInCurrentCompilation(BuildNamespace(), name) ?? + sourceInputModel.FindForTypeInCurrentCompilation(BuildNamespace(), generatedName); + var isCustomization = customType?.Attributes.Any(attribute => + attribute.Type.Name == "CodeGenTypeAttribute" && + attribute.Arguments.FirstOrDefault() is LiteralExpression { Literal: string customName } && + (customName == name || customName == generatedName)) == true; + if (customType is not null && !isCustomization) + { + return true; + } + + var emittedName = customType?.Name ?? name; + if (typeFactory.IsModelNameUsedByAnotherModel(emittedName, _inputModel)) + { + return true; + } + + var expectedFilePath = Path.Combine("src", "Generated", "Models", $"{emittedName}.cs"); + if (ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.Enums.Any(inputEnum => + inputEnum.External is null && + string.Equals(EnumProvider.Create(inputEnum).RelativeFilePath, expectedFilePath, StringComparison.OrdinalIgnoreCase))) + { + return true; + } + return !typeFactory.TryReserveUnknownDiscriminatorModelName(emittedName, _inputModel); + } + protected override TypeSignatureModifiers BuildDeclarationModifiers() { var modifiers = base.BuildDeclarationModifiers(); diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmTypeFactory.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmTypeFactory.cs index 1f9bece558a..34720a7f7ca 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmTypeFactory.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmTypeFactory.cs @@ -28,6 +28,12 @@ public class ScmTypeFactory : TypeFactory protected override IEnumerable<(string Name, string Namespace, string OriginalName)> GetReservedModelTypeNames() => ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.Clients.Select(ClientProvider.GetNameForCollisionCheck); + internal bool IsModelNameUsedByAnotherModel(string name, InputModelType exceptModel) + => base.HasModelNameCollision(name, exceptModel); + + internal bool TryReserveUnknownDiscriminatorModelName(string name, InputModelType model) + => base.TryReserveRestoredModelName(name, model); + public virtual CSharpType MatchConditionsType => typeof(PipelineMessageClassifier); public virtual IClientResponseApi ClientResponseApi => ClientResultProvider.Instance; diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/DiscriminatorTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/DiscriminatorTests.cs index 980c736d905..5db28cad51a 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/DiscriminatorTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/DiscriminatorTests.cs @@ -3,11 +3,16 @@ using System.ClientModel.Primitives; using System.Collections.Generic; +using System.IO; using System.Linq; +using System.Threading.Tasks; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; using Microsoft.TypeSpec.Generator.ClientModel.Providers; using Microsoft.TypeSpec.Generator.Input; using Microsoft.TypeSpec.Generator.Primitives; using Microsoft.TypeSpec.Generator.Providers; +using Microsoft.TypeSpec.Generator.SourceInput; using Microsoft.TypeSpec.Generator.Statements; using Microsoft.TypeSpec.Generator.Tests.Common; using NUnit.Framework; @@ -172,6 +177,263 @@ public void UnknownVariantPersistableCreateCoreShouldReturnDeserializeBase() Assert.IsTrue(statements!.Statements.Last().ToDisplayString().Contains("DeserializePet")); } + [TestCase(false)] + [TestCase(true)] + public async Task HistoricalUnknownNameUsedBySerialization(bool isPublic) + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isRequired: true, isDiscriminator: true)]); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + compilation: isPublic ? async () => await Helpers.GetCompilationFromDirectoryAsync("Public") : null, + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync()); + var generator = ScmCodeModelGenerator.Instance; + var model = generator.TypeFactory.CreateModel(input)!; + var unknown = model.DerivedModels.Single(m => m.IsUnknownDiscriminatorModel); + var serialization = model.SerializationProviders.Single(); + var unknownSerialization = unknown.SerializationProviders.Single(); + var proxyAttribute = serialization.Attributes.Single(a => a.Type.Equals(typeof(PersistableModelProxyAttribute))); + + Assert.AreEqual("UnknownActivity", unknown.Name); + Assert.AreEqual(Helpers.GetExpectedFromFile().Trim(), proxyAttribute.ToDisplayString().Trim()); + Assert.AreEqual("UnknownActivity", unknownSerialization.Name); + Assert.IsTrue(unknownSerialization.Methods.Any(m => m.Signature.Name == "DeserializeUnknownActivity")); + var deserialize = serialization.Methods.Single(m => m.Signature.Name == "DeserializePipelineActivity"); + StringAssert.Contains("UnknownActivity", deserialize.BodyStatements!.ToDisplayString()); + StringAssert.DoesNotContain("UnknownPipelineActivity", deserialize.BodyStatements.ToDisplayString()); + var factoryMethod = generator.OutputLibrary.ModelFactory.Value.Methods.Single(m => m.Signature.Name == "PipelineActivity"); + StringAssert.Contains("UnknownActivity", factoryMethod.BodyStatements!.ToDisplayString()); + var context = generator.OutputLibrary.TypeProviders.OfType().Single(); + Assert.AreEqual(isPublic, context.Attributes.Any(a => a.ToDisplayString().Contains("UnknownActivity"))); + } + + [Test] + public async Task HistoricalUnknownNameRestoredPerHierarchyLevel() + { + var root = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var child = InputFactory.Model("CopyActivitySource", baseModel: root, discriminatedKind: "copy", properties: + [InputFactory.Property("sourceKind", InputPrimitiveType.String, isDiscriminator: true)]); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [child, root], + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync()); + var factory = ScmCodeModelGenerator.Instance.TypeFactory; + var rootUnknown = factory.CreateModel(root.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + var childUnknown = factory.CreateModel(child.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("UnknownActivity", rootUnknown.Name); + Assert.AreEqual("UnknownCopySource", childUnknown.Name); + } + + [Test] + public async Task HistoricalUnknownNamePreservesLegacyCustomization() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + compilation: async () => await Helpers.GetCompilationFromDirectoryAsync(), + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization))); + var unknown = ScmCodeModelGenerator.Instance.TypeFactory + .CreateModel(input.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("CustomUnknownActivity", unknown.CustomCodeView?.Name); + Assert.AreEqual("Sample.Customizations", unknown.CustomCodeView?.Type.Namespace); + Assert.IsTrue(unknown.CustomCodeView!.Methods.Any(m => m.Signature.Name == "CustomMethod")); + Assert.AreEqual("CustomUnknownActivity", unknown.Name); + } + + [Test] + public async Task HistoricalUnknownNameRestoredFromDllBackedLastContract() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var lastContract = await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization)); + var fixtureDirectory = nameof(HistoricalUnknownNameUsedBySerialization); + var fixtureTrees = lastContract.SyntaxTrees.Where(tree => + Path.GetFileName(Path.GetDirectoryName(tree.FilePath)) == fixtureDirectory); + var fixtureCompilation = CSharpCompilation.Create( + "HistoricalUnknownNameDll", + fixtureTrees, + lastContract.References.Append( + MetadataReference.CreateFromFile(System.Reflection.Assembly.Load("System.Runtime").Location)), + new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); + using var assemblyStream = new MemoryStream(); + var emitResult = fixtureCompilation.Emit(assemblyStream); + Assert.That(emitResult.Success, Is.True, string.Join("\n", emitResult.Diagnostics)); + var dllBackedLastContract = fixtureCompilation.RemoveAllSyntaxTrees() + .AddReferences(MetadataReference.CreateFromImage(assemblyStream.ToArray())); + + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + lastContractCompilation: () => Task.FromResult(dllBackedLastContract)); + var unknown = ScmCodeModelGenerator.Instance.TypeFactory + .CreateModel(input.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("UnknownActivity", unknown.Name); + } + + [Test] + public async Task HistoricalUnknownNameNotRestoredWhenNoProxyAttribute() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameNotRestoredWhenNoProxyAttribute))); + var unknown = ScmCodeModelGenerator.Instance.TypeFactory + .CreateModel(input.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("UnknownPipelineActivity", unknown.Name); + } + + [TestCase("UnknownActivity", "Sample.Models")] + [TestCase("unknownactivity", "Other.Models")] + public async Task HistoricalUnknownNameNotRestoredWhenUsedByAnotherModel(string collisionName, string collisionNamespace) + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var collision = InputFactory.Model(collisionName, @namespace: collisionNamespace, isExactName: true); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input, collision], + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization))); + var model = ScmCodeModelGenerator.Instance.TypeFactory.CreateModel(input)!; + + Assert.AreEqual("UnknownPipelineActivity", model.DerivedModels.Single(m => m.IsUnknownDiscriminatorModel).Name); + } + + [Test] + public async Task HistoricalUnknownNameNotRestoredWhenCustomizedOutputNameCollides() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var collision = InputFactory.Model("CustomUnknown", isExactName: true); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input, collision], + compilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameNotRestoredWhenCustomizedOutputNameCollides)), + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization))); + var unknown = ScmCodeModelGenerator.Instance.TypeFactory + .CreateModel(input.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("UnknownPipelineActivity", unknown.Name); + } + + [TestCase(false)] + [TestCase(true)] + public async Task HistoricalUnknownNameIsReservedAcrossModels(bool reverseOrder) + { + var first = InputFactory.Model("FirstBase", @namespace: "Sample.Models", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var second = InputFactory.Model("SecondBase", @namespace: "Other.Models", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + InputModelType[] models = reverseOrder ? [second, first] : [first, second]; + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => models, + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameIsReservedAcrossModels))); + var factory = ScmCodeModelGenerator.Instance.TypeFactory; + ModelProvider firstUnknown; + ModelProvider secondUnknown; + if (reverseOrder) + { + secondUnknown = factory.CreateModel(second.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + firstUnknown = factory.CreateModel(first.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + } + else + { + firstUnknown = factory.CreateModel(first.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + secondUnknown = factory.CreateModel(second.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + } + + Assert.AreNotEqual(firstUnknown.Name, secondUnknown.Name); + Assert.AreEqual( + "UnknownLegacy", + reverseOrder ? secondUnknown.Name : firstUnknown.Name); + } + + [Test] + public async Task HistoricalUnknownNameIsNotRestoredWhenRemovalIsAcceptedInBaseline() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var baseline = ApiCompatBaseline.Parse( + ["TypesMustExist: Type 'Sample.Models.UnknownActivity' does not exist"]); + var generator = await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization))); + generator.Object.SourceInputModel = new SourceInputModel( + null, + generator.Object.SourceInputModel.LastContract, + baseline); + var unknown = ScmCodeModelGenerator.Instance.TypeFactory + .CreateModel(input.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("UnknownPipelineActivity", unknown.Name); + } + + [Test] + public async Task HistoricalUnknownNameNotRestoredWhenUsedByEnum() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var collision = InputFactory.StringEnum("UnknownActivity", [("one", "one")]); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + inputEnums: () => [collision], + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization))); + var model = ScmCodeModelGenerator.Instance.TypeFactory.CreateModel(input)!; + + Assert.AreEqual("UnknownPipelineActivity", model.DerivedModels.Single(m => m.IsUnknownDiscriminatorModel).Name); + } + + [Test] + public async Task HistoricalUnknownNameNotRestoredWhenUsedByUnrelatedCustomType() + { + var input = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => [input], + compilation: async () => await Helpers.GetCompilationFromDirectoryAsync(), + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync( + method: nameof(HistoricalUnknownNameUsedBySerialization))); + var model = ScmCodeModelGenerator.Instance.TypeFactory.CreateModel(input)!; + + Assert.AreEqual("UnknownPipelineActivity", model.DerivedModels.Single(m => m.IsUnknownDiscriminatorModel).Name); + } + + [TestCase(false)] + [TestCase(true)] + public async Task RejectedHistoricalNameReservesFallbackBeforeOtherRestoration(bool reverseOrder) + { + var pipeline = InputFactory.Model("PipelineActivity", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var job = InputFactory.Model("JobDetails", properties: + [InputFactory.Property("kind", InputPrimitiveType.String, isDiscriminator: true)]); + var collision = InputFactory.Model("UnknownActivity", isExactName: true); + InputModelType[] models = reverseOrder + ? [job, collision, pipeline] + : [pipeline, job, collision]; + + await MockHelpers.LoadMockGeneratorAsync( + inputModels: () => models, + lastContractCompilation: async () => await Helpers.GetCompilationFromDirectoryAsync()); + var factory = ScmCodeModelGenerator.Instance.TypeFactory; + var pipelineUnknown = factory.CreateModel(pipeline.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + var jobUnknown = factory.CreateModel(job.DiscriminatedSubtypes.Values.Single(m => m.IsUnknownDiscriminatorModel))!; + + Assert.AreEqual("UnknownPipelineActivity", pipelineUnknown.Name); + Assert.AreEqual("UnknownJobDetails", jobUnknown.Name); + Assert.AreNotEqual(pipelineUnknown.Name, jobUnknown.Name); + } + [Test] public void BaseShouldHaveProxyAttribute() { diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameIsReservedAcrossModels/Models.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameIsReservedAcrossModels/Models.cs new file mode 100644 index 00000000000..2b311a62c10 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameIsReservedAcrossModels/Models.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +namespace Sample.Models +{ + [System.ClientModel.Primitives.PersistableModelProxy(typeof(UnknownLegacy))] + public abstract class FirstBase { } + + internal class UnknownLegacy : FirstBase { } +} + +namespace Other.Models +{ + [System.ClientModel.Primitives.PersistableModelProxy(typeof(UnknownLegacy))] + public abstract class SecondBase { } + + internal class UnknownLegacy : SecondBase { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenCustomizedOutputNameCollides/CustomUnknown.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenCustomizedOutputNameCollides/CustomUnknown.cs new file mode 100644 index 00000000000..023d82a6be9 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenCustomizedOutputNameCollides/CustomUnknown.cs @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using Microsoft.TypeSpec.Generator.Customizations; + +namespace Sample.Models +{ + [CodeGenType("UnknownActivity")] + public partial class CustomUnknown { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenNoProxyAttribute/Models.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenNoProxyAttribute/Models.cs new file mode 100644 index 00000000000..336622f50cb --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenNoProxyAttribute/Models.cs @@ -0,0 +1,7 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +namespace Sample.Models +{ + public abstract class PipelineActivity { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenUsedByUnrelatedCustomType/UnknownActivity.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenUsedByUnrelatedCustomType/UnknownActivity.cs new file mode 100644 index 00000000000..98ae29b46d4 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameNotRestoredWhenUsedByUnrelatedCustomType/UnknownActivity.cs @@ -0,0 +1,7 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +namespace Sample.Models +{ + public class UnknownActivity { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNamePreservesLegacyCustomization/CustomUnknownActivity.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNamePreservesLegacyCustomization/CustomUnknownActivity.cs new file mode 100644 index 00000000000..89d25f06213 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNamePreservesLegacyCustomization/CustomUnknownActivity.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using Microsoft.TypeSpec.Generator.Customizations; + +namespace Sample.Customizations +{ + [CodeGenType("UnknownPipelineActivity")] + public partial class CustomUnknownActivity + { + public void CustomMethod() { } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameRestoredPerHierarchyLevel/Models.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameRestoredPerHierarchyLevel/Models.cs new file mode 100644 index 00000000000..d90bd2c3cde --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameRestoredPerHierarchyLevel/Models.cs @@ -0,0 +1,15 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +namespace Sample.Models +{ + [System.ClientModel.Primitives.PersistableModelProxy(typeof(UnknownActivity))] + public abstract class PipelineActivity { } + + [System.ClientModel.Primitives.PersistableModelProxy(typeof(UnknownCopySource))] + public abstract class CopyActivitySource : PipelineActivity { } + + internal class UnknownActivity : PipelineActivity { } + + internal class UnknownCopySource : CopyActivitySource { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization(Public)/UnknownActivity.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization(Public)/UnknownActivity.cs new file mode 100644 index 00000000000..a767e9115d1 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization(Public)/UnknownActivity.cs @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using Microsoft.TypeSpec.Generator.Customizations; + +namespace Sample.Models +{ + [CodeGenType("UnknownPipelineActivity")] + public partial class UnknownActivity { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization.cs new file mode 100644 index 00000000000..458162dc5ff --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization.cs @@ -0,0 +1 @@ +[global::System.ClientModel.Primitives.PersistableModelProxyAttribute(typeof(global::Sample.Models.UnknownActivity))] diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization/Models.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization/Models.cs new file mode 100644 index 00000000000..66a0346a084 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/HistoricalUnknownNameUsedBySerialization/Models.cs @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +namespace Sample.Models +{ + [System.ClientModel.Primitives.PersistableModelProxy(typeof(UnknownActivity))] + public abstract class PipelineActivity { } + + internal class UnknownActivity : PipelineActivity { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/RejectedHistoricalNameReservesFallbackBeforeOtherRestoration/Models.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/RejectedHistoricalNameReservesFallbackBeforeOtherRestoration/Models.cs new file mode 100644 index 00000000000..46c27b85241 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/TestData/DiscriminatorTests/RejectedHistoricalNameReservesFallbackBeforeOtherRestoration/Models.cs @@ -0,0 +1,17 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System.ClientModel.Primitives; + +namespace Sample.Models +{ + [PersistableModelProxy(typeof(UnknownActivity))] + public abstract class PipelineActivity { } + + [PersistableModelProxy(typeof(UnknownPipelineActivity))] + public abstract class JobDetails { } + + internal class UnknownActivity : PipelineActivity { } + + internal class UnknownPipelineActivity : JobDetails { } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/BackCompatibilityChangeCategory.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/BackCompatibilityChangeCategory.cs index adb294c57e2..d1b45c4aac0 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/BackCompatibilityChangeCategory.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/BackCompatibilityChangeCategory.cs @@ -63,5 +63,8 @@ public enum BackCompatibilityChangeCategory /// A model base type was preserved from the last contract. ModelBaseTypePreserved, + + /// An unknown discriminator model name could not be preserved because it collides with another type. + UnknownDiscriminatorModelNameSkipped, } } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/Emitter.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/Emitter.cs index 1552b25c58e..680336fd965 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/Emitter.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/EmitterRpc/Emitter.cs @@ -175,6 +175,7 @@ public void WriteBufferedMessages() BackCompatibilityChangeCategory.AdditionalPropertiesShapePreserved => "AdditionalProperties Shape Preserved", BackCompatibilityChangeCategory.PropertyTypePreserved => "Property Type Preserved", BackCompatibilityChangeCategory.ModelBaseTypePreserved => "Model Base Type Preserved", + BackCompatibilityChangeCategory.UnknownDiscriminatorModelNameSkipped => "Unknown Discriminator Model Name Back-Compat Skipped", BackCompatibilityChangeCategory.ConstructorModifierPreserved => "Constructor Modifier Preserved", BackCompatibilityChangeCategory.EnumMemberReordering => "Enum Member Reordering", BackCompatibilityChangeCategory.ApiVersionEnumMemberAdded => "Api Version Enum Member Added From Last Contract", diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/TypeFactory.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/TypeFactory.cs index 6b52511e778..9436fdb2132 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/TypeFactory.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/TypeFactory.cs @@ -35,6 +35,29 @@ internal IEnumerable CreatedModelProviders private IReadOnlyDictionary? _modelNames; internal IReadOnlyDictionary ModelNames => _modelNames ??= BuildModelNames(); + private IReadOnlyDictionary? _emittedModelNames; + private IReadOnlyDictionary? _fallbackModelNames; + private readonly HashSet _restoredModelNames = new(StringComparer.OrdinalIgnoreCase); + + protected bool HasModelNameCollision(string name, InputModelType exceptModel) + { + _ = ModelNames; + return _restoredModelNames.Contains(name) || + _emittedModelNames!.Any(model => + model.Key != exceptModel && string.Equals(model.Value, name, StringComparison.OrdinalIgnoreCase)) || + _fallbackModelNames!.Any(model => + model.Key != exceptModel && string.Equals(model.Value, name, StringComparison.OrdinalIgnoreCase)); + } + + protected bool TryReserveRestoredModelName(string name, InputModelType model) + { + if (HasModelNameCollision(name, model)) + { + return false; + } + + return _restoredModelNames.Add(name); + } protected virtual IEnumerable<(string Name, string Namespace, string OriginalName)> GetReservedModelTypeNames() => []; @@ -87,6 +110,8 @@ void AddModel(InputModelType model) } var result = new Dictionary(); + var emittedModelNames = new Dictionary(); + var fallbackModelNames = candidates.ToDictionary(candidate => candidate.Key, candidate => candidate.Value.Name); foreach (var (model, candidate) in candidates) { // A direct input takes precedence over an implicit suffix match for the same mapping. @@ -96,6 +121,7 @@ void AddModel(InputModelType model) (nameCounts[candidate.FinalName] == 1 && !reservedTypes.Contains((candidate.FinalName, candidate.FinalNamespace)))) { result.Add(model, candidate.Name); + emittedModelNames.Add(model, candidate.FinalName); continue; } @@ -109,8 +135,11 @@ void AddModel(InputModelType model) } ReserveName(name); result.Add(model, name); + emittedModelNames.Add(model, name); } + _emittedModelNames = emittedModelNames; + _fallbackModelNames = fallbackModelNames; return result; }