[Draft] Use hybrid C# reference map for post-processing

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

@@ -424,6 +424,60 @@ private IReadOnlyList<ParameterProvider> GetClientParameters()
 
         protected override string BuildName() => _inputClient.IsExactName ? _inputClient.Name : _inputClient.Name.ToIdentifierName();
 
+        protected override IReadOnlyList<CSharpType> BuildBodyDependencyTypes()
+        {
+            var dependencies = new List<CSharpType>();
+            foreach (var method in Methods.OfType<ScmMethodProvider>())
+            {
+                if (method.BodyStatements == null)
+                {
+                    continue;
+                }
+
+                if (method.CollectionDefinition != null)
+                {
+                    dependencies.Add(method.CollectionDefinition.Type);
+                }
+
+                if (method.ServiceMethod == null)
+                {
+                    continue;
+                }
+
+                AddInputTypeDependency(dependencies, method.ServiceMethod.Response.Type);
+                AddInputTypeDependency(dependencies, method.ServiceMethod.Exception?.Type);
+                foreach (var parameter in method.ServiceMethod.Parameters)
+                {
+                    AddInputTypeDependency(dependencies, parameter.Type);
+                }
+
+                foreach (var parameter in method.ServiceMethod.Operation.Parameters)
+                {
+                    AddInputTypeDependency(dependencies, parameter.Type);
+                }
+
+                foreach (var response in method.ServiceMethod.Operation.Responses)
+                {
+                    AddInputTypeDependency(dependencies, response.BodyType);
+                    foreach (var header in response.Headers)
+                    {
+                        AddInputTypeDependency(dependencies, header.Type);
+                    }
+                }
+            }
+
+            return dependencies;
+        }
+
+        private static void AddInputTypeDependency(List<CSharpType> dependencies, InputType? inputType)
+        {
+            var type = inputType == null ? null : ScmCodeModelGenerator.Instance.TypeFactory.CreateCSharpType(inputType);
+            if (type != null)
+            {
+                dependencies.Add(type);
+            }
+        }
+
         protected override FieldProvider[] BuildFields()
         {
             List<FieldProvider> fields = [EndpointField];

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

@@ -217,6 +217,22 @@ private bool HasPagingOperationNameCollision(string operationName)
         protected override TypeSignatureModifiers BuildDeclarationModifiers()
             => TypeSignatureModifiers.Internal | TypeSignatureModifiers.Partial | TypeSignatureModifiers.Class;
 
+        protected override IReadOnlyList<CSharpType> BuildBodyDependencyTypes()
+        {
+            var dependencies = new List<CSharpType> { Client.Type, ResponseModelType, NextPagePropertyType };
+            if (ItemModelType != null)
+            {
+                dependencies.Add(ItemModelType);
+            }
+
+            foreach (var field in RequestFields)
+            {
+                dependencies.Add(field.Type);
+            }
+
+            return dependencies;
+        }
+
         protected override FieldProvider[] BuildFields() => [ClientField, .. RequestFields];
 
         protected override CSharpType[] BuildImplements() =>

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

@@ -117,6 +117,10 @@ public MrwSerializationTypeDefinition(InputModelType inputModel, ModelProvider m
 
         protected override CSharpType? BuildBaseType() => _model.BaseType;
 
+        protected override IReadOnlyList<string> BuildHelperDependencyNames() => _rawDataField != null || _additionalProperties.Value.Length > 0
+            ? ["ChangeTrackingDictionary"]
+            : [];
+
         protected override SuppressionStatement[] BuildDisabledFileWarnings()
         {
             if (_model.CanonicalView.Properties.Any(p => ScmModelProvider.IsFileBinaryContentType(p.Type)))

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

@@ -51,6 +51,12 @@ protected override string BuildRelativeFilePath()
             return Path.Combine("src", "Generated", "Models", $"{Name}.Serialization.Multipart.cs");
         }
 
+        protected override IReadOnlyList<string> BuildHelperDependencyNames() => _model.Properties.Any(
+            prop => prop.WireInfo != null && !prop.WireInfo.IsRequired &&
+                (prop.Type is { IsCollection: true, IsReadOnlyMemory: false } || prop.Type.IsDictionary))
+            ? ["Optional"]
+            : [];
+
         protected override SuppressionStatement[] BuildDisabledFileWarnings()
             => [new SuppressionStatement(null, Literal(ScmModelProvider.FileBinaryContentDiagnosticId), ScmModelProvider.ScmEvaluationTypeSuppressionJustification)];
 

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

@@ -78,6 +78,33 @@ protected override FieldProvider[] BuildFields()
             return [.. pipelineMessage20xClassifiersFields];
         }
 
+        protected override IReadOnlyList<string> BuildHelperDependencyNames()
+        {
+            var dependencies = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var serviceMethod in _inputClient.Methods)
+            {
+                foreach (var parameter in serviceMethod.Operation.Parameters)
+                {
+                    if (parameter is not InputHeaderParameter and not InputQueryParameter)
+                    {
+                        continue;
+                    }
+
+                    var type = ScmCodeModelGenerator.Instance.TypeFactory.CreateCSharpType(parameter.Type);
+                    if (type?.IsDictionary == true)
+                    {
+                        dependencies.Add("ChangeTrackingDictionary");
+                    }
+                    else if (type?.IsCollection == true)
+                    {
+                        dependencies.Add("ChangeTrackingList");
+                    }
+                }
+            }
+
+            return [.. dependencies];
+        }
+
         protected override ScmMethodProvider[] BuildMethods()
         {
             List<ScmMethodProvider> methods = new List<ScmMethodProvider>();

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/PostProcessing/ClientBodyDependencyPostProcessingTests.cs

@@ -0,0 +1,234 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.TypeSpec.Generator.Input;
+using Microsoft.TypeSpec.Generator.Tests.Common;
+using NUnit.Framework;
+
+namespace Microsoft.TypeSpec.Generator.ClientModel.Tests.PostProcessing
+{
+    public class ClientBodyDependencyPostProcessingTests
+    {
+        [Test]
+        public async Task OperationBodyParameterModelDoesNotBecomePublic()
+        {
+            var requestModel = InputFactory.Model("RequestBody");
+            var parameter = InputFactory.BodyParameter("body", requestModel, isRequired: true);
+            var operation = InputFactory.Operation("Create", parameters: [parameter], httpMethod: "POST");
+            var method = InputFactory.BasicServiceMethod("Create", operation);
+            var client = InputFactory.Client("TestClient", methods: [method]);
+
+            await GenerateAndAssertInternalModels([requestModel], [client], ["RequestBody"]);
+        }
+
+        [Test]
+        public async Task OperationResponseBodyModelRemainsPublicAsRootOutputModel()
+        {
+            var responseModel = InputFactory.Model("ResponseBody");
+            var operation = InputFactory.Operation("Get", responses: [InputFactory.OperationResponse(bodytype: responseModel)]);
+            var method = InputFactory.BasicServiceMethod(
+                "Get",
+                operation,
+                response: InputFactory.ServiceMethodResponse(InputPrimitiveType.String, []));
+            var client = InputFactory.Client("TestClient", methods: [method]);
+
+            await GenerateAndAssertPublicModels([responseModel], [client], ["ResponseBody"]);
+        }
+
+        [Test]
+        public async Task NestedBodyModelGraphDoesNotBecomePublic()
+        {
+            var nestedModel = InputFactory.Model("NestedToolParameter");
+            var toolModel = InputFactory.Model(
+                "ToolConfig",
+                properties: [InputFactory.Property("Parameter", nestedModel)]);
+            var parameter = InputFactory.BodyParameter("tool", toolModel, isRequired: true);
+            var operation = InputFactory.Operation("Configure", parameters: [parameter], httpMethod: "POST");
+            var method = InputFactory.BasicServiceMethod("Configure", operation);
+            var client = InputFactory.Client("TestClient", methods: [method]);
+
+            await GenerateAndAssertInternalModels([toolModel, nestedModel], [client], ["ToolConfig", "NestedToolParameter"]);
+        }
+
+        [Test]
+        public async Task NonDiscriminatorDerivedBodyModelDoesNotBecomePublicFromPublicBase()
+        {
+            var baseTool = InputFactory.Model("BaseTool");
+            var concreteTool = InputFactory.Model(
+                "ConcreteTool",
+                properties: [InputFactory.Property("Name", InputPrimitiveType.String)],
+                baseModel: baseTool);
+            var operation = InputFactory.Operation("Get", responses: [InputFactory.OperationResponse(bodytype: baseTool)]);
+            var method = InputFactory.BasicServiceMethod("Get", operation, response: InputFactory.ServiceMethodResponse(baseTool, []));
+            var client = InputFactory.Client("TestClient", methods: [method]);
+
+            await GenerateAndAssertMixedModels(
+                [baseTool, concreteTool],
+                [client],
+                publicModelNames: ["BaseTool"],
+                internalModelNames: ["ConcreteTool"]);
+        }
+
+        [Test]
+        public async Task CustomizedEnumSerializationProviderIsKeptWhenModelSerializationUsesEnum()
+        {
+            var statusEnum = InputFactory.StringEnum(
+                "Status",
+                [("Succeeded", "succeeded"), ("Failed", "failed")],
+                clientNamespace: "Sample");
+            var resultModel = InputFactory.Model(
+                "OperationResult",
+                properties: [InputFactory.Property("Status", statusEnum, isRequired: true)],
+                @namespace: "Sample");
+            var operation = InputFactory.Operation("Get", responses: [InputFactory.OperationResponse(bodytype: resultModel)]);
+            var method = InputFactory.BasicServiceMethod("Get", operation, response: InputFactory.ServiceMethodResponse(resultModel, []));
+            var client = InputFactory.Client("TestClient", methods: [method], clientNamespace: "Sample");
+
+            await GenerateAndAssertFiles(
+                enums: [statusEnum],
+                models: [resultModel],
+                clients: [client],
+                customFiles: [
+                    (Path.Combine("src", "Custom", "Status.cs"), """
+                        namespace Sample;
+
+                        [CodeGenType("Status")]
+                        public enum Status
+                        {
+                            Succeeded,
+                            Failed
+                        }
+                        """)
+                ],
+                expectedFiles: [Path.Combine("src", "Generated", "Models", "Status.Serialization.cs")]);
+        }
+
+        private static async Task GenerateAndAssertInternalModels(
+            InputModelType[] models,
+            InputClient[] clients,
+            string[] modelNames)
+            => await GenerateAndAssertModels(models, clients, modelNames, shouldBePublic: false);
+
+        private static async Task GenerateAndAssertPublicModels(
+            InputModelType[] models,
+            InputClient[] clients,
+            string[] modelNames)
+            => await GenerateAndAssertModels(models, clients, modelNames, shouldBePublic: true);
+
+        private static async Task GenerateAndAssertMixedModels(
+            InputModelType[] models,
+            InputClient[] clients,
+            string[] publicModelNames,
+            string[] internalModelNames)
+            => await GenerateAndAssertModels(models, clients, publicModelNames, internalModelNames);
+
+        private static async Task GenerateAndAssertModels(
+            InputModelType[] models,
+            InputClient[] clients,
+            string[] modelNames,
+            bool shouldBePublic)
+            => await GenerateAndAssertModels(
+                models,
+                clients,
+                shouldBePublic ? modelNames : [],
+                shouldBePublic ? [] : modelNames);
+
+        private static async Task GenerateAndAssertModels(
+            InputModelType[] models,
+            InputClient[] clients,
+            string[] publicModelNames,
+            string[] internalModelNames)
+        {
+            await GenerateAndAssertFiles(
+                enums: [],
+                models: models,
+                clients: clients,
+                customFiles: [],
+                publicModelNames: publicModelNames,
+                internalModelNames: internalModelNames,
+                expectedFiles: []);
+        }
+
+        private static async Task GenerateAndAssertFiles(
+            InputEnumType[] enums,
+            InputModelType[] models,
+            InputClient[] clients,
+            (string Path, string Content)[] customFiles,
+            string[] expectedFiles,
+            string[] publicModelNames = null!,
+            string[] internalModelNames = null!)
+        {
+            publicModelNames ??= [];
+            internalModelNames ??= [];
+
+            var outputPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(outputPath);
+            try
+            {
+                foreach (var customFile in customFiles)
+                {
+                    var customPath = Path.Combine(outputPath, customFile.Path);
+                    Directory.CreateDirectory(Path.GetDirectoryName(customPath)!);
+                    File.WriteAllText(customPath, customFile.Content);
+                }
+
+                await MockHelpers.LoadMockGeneratorAsync(
+                    inputEnums: () => enums,
+                    inputModels: () => models,
+                    clients: () => clients,
+                    configuration: "{\"package-name\": \"Sample\", \"disable-xml-docs\": true}",
+                    outputPath: outputPath);
+
+                await new CSharpGen().ExecuteAsync();
+
+                foreach (var modelName in publicModelNames)
+                {
+                    var modelPath = Path.Combine(outputPath, "src", "Generated", "Models", $"{modelName}.cs");
+                    Assert.IsTrue(File.Exists(modelPath), $"Expected generated model file '{modelPath}'.");
+                    var text = File.ReadAllText(modelPath);
+                    StringAssert.Contains($"public partial class {modelName}", text, $"{modelName} should be public.");
+                }
+
+                foreach (var modelName in internalModelNames)
+                {
+                    var modelPath = Path.Combine(outputPath, "src", "Generated", "Models", $"{modelName}.cs");
+                    Assert.IsTrue(File.Exists(modelPath), $"Expected generated model file '{modelPath}'.");
+                    var text = File.ReadAllText(modelPath);
+                    StringAssert.Contains($"internal partial class {modelName}", text, $"{modelName} should be internal.");
+                    StringAssert.DoesNotContain($"public partial class {modelName}", text, $"{modelName} should not be public.");
+                }
+
+                var modelFactoryPath = Path.Combine(outputPath, "src", "Generated", "SampleModelFactory.cs");
+                if (File.Exists(modelFactoryPath))
+                {
+                    var modelFactoryText = File.ReadAllText(modelFactoryPath);
+                    foreach (var modelName in publicModelNames)
+                    {
+                        StringAssert.Contains($" {modelName}(", modelFactoryText, $"Model factory method for {modelName} should be generated.");
+                    }
+
+                    foreach (var modelName in internalModelNames)
+                    {
+                        StringAssert.DoesNotContain($" {modelName}(", modelFactoryText, $"Model factory method for {modelName} should not be generated.");
+                    }
+                }
+
+                foreach (var expectedFile in expectedFiles)
+                {
+                    var filePath = Path.Combine(outputPath, expectedFile);
+                    Assert.IsTrue(File.Exists(filePath), $"Expected generated file '{filePath}'.");
+                }
+            }
+            finally
+            {
+                if (Directory.Exists(outputPath))
+                {
+                    Directory.Delete(outputPath, recursive: true);
+                }
+            }
+        }
+    }
+}