Put all optional client parameters into client options

docs/features/service_client_constructors.md

@@ -0,0 +1,56 @@
+## Service Client Constrctors
+
+Scope: This document only applies to DPG services.
+
+There will be two **public** client constructors in a generated service client. One primary public constructor with all the user defined client parameters plus `ClientOptions`, and one secondary public constructor with all the user defined **required** client parameters. The secondary public constructor calls the primary public constructor underneath.
+
+For example, user defines required parameters `Uri endpoint` and `AzureKeyCredential credential`, then the generated public constructors are:
+
+```C#
+public ServiceClient(Uri endpoint, AzureKeyCredential credential) : this(endpoint, credential, new ServiceClientOptions()) {}
+
+public ServiceClient(Uri endpoint, AzureKeyCredential credential, ServiceClientOptions options) {}
+```
+
+Normally, all the client parameters are required. But if user defines some additional optional client parameters, all the optional client parameters will go to `ClientOptions`, except `endpoint`.
+
+For example, user defines an optional parameter `string optional`. The `ClientOptions` will have a new property as
+
+```C#
+public partial class ServiceClientOptions : ClientOptions
+{
+    ...
+
+    public string Optional { get; set; }
+}
+```
+
+The signature of the public constructors will keep the same, but its implementation will become to
+```C#
+public ServiceClient(Uri endpoint, AzureKeyCredential credential) : this(endpoint, credential, new ServiceClientOptions()) {}
+
+public ServiceClient(Uri endpoint, AzureKeyCredential credential, ServiceClientOptions options)
+{
+    ...
+    _optional = options.Optional;
+}
+```
+
+If the optional client parameters user defines contains `endpoint`, it will still be in the client constructor, not going to `ClientOptions`. For example, user defines an optional parameter `string optional`, an optional `endpoint` with default value `"http://localhost:3000"`, and a required parameter `AzureKeyCredential credential`, the generated public constructors are:
+
+```C#
+public ServiceClient(AzureKeyCredential credential) : this(new Uri("http://localhost:3000"), credential, new ServiceClientOptions()) {}
+
+public ServiceClient(Uri endpoint, AzureKeyCredential credential, ServiceClientOptions options)
+{
+    ...
+    _optional = options.Optional;
+}
+
+public partial class ServiceClientOptions : ClientOptions
+{
+    ...
+
+    public string Optional { get; set; }
+}
+```

src/AutoRest.CSharp/Common/Generation/Writers/ClientOptionsWriter.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using AutoRest.CSharp.Common.Input;
 using AutoRest.CSharp.Output.Models.Types;
+using AutoRest.CSharp.Utilities;
 
 namespace AutoRest.CSharp.Generation.Writers
 {
@@ -49,6 +50,15 @@ public static void WriteClientOptions(CodeWriter writer, ClientOptionsTypeProvid
                                 writer.Line($"_ => throw new {typeof(NotSupportedException)}()");
                             }
                         }
+
+                        writer.Line();
+                    }
+
+                    foreach (var parameter in clientOptions.AdditionalParameters)
+                    {
+                        writer.WriteXmlDocumentationSummary(parameter.Description);
+                        writer.Line($"public {parameter.Type} {parameter.Name.ToCleanName()} {{ get; set; }}");
+                        writer.Line();
                     }
                 }
             }

src/AutoRest.CSharp/Common/Output/Models/Shared/KnownParameters.cs

@@ -26,7 +26,7 @@ internal static class KnownParameters
         public static readonly Parameter Pipeline = new("pipeline", $"The HTTP pipeline for sending and receiving REST requests and responses", new CSharpType(Configuration.ApiTypes.HttpPipelineType), null, ValidationType.AssertNotNull, null);
         public static readonly Parameter KeyAuth = new("keyCredential", $"The key credential to copy", new CSharpType(Configuration.ApiTypes.KeyCredentialType), null, ValidationType.None, null);
         public static readonly Parameter TokenAuth = new("tokenCredential", $"The token credential to copy", new CSharpType(typeof(TokenCredential)), null, ValidationType.None, null);
-        public static readonly Parameter Endpoint = new("endpoint", $"Service endpoint", new CSharpType(typeof(Uri)), null, ValidationType.None, null, RequestLocation: RequestLocation.Uri);
+        public static readonly Parameter Endpoint = new("endpoint", $"Service endpoint", new CSharpType(typeof(Uri)), null, ValidationType.None, null, RequestLocation: RequestLocation.Uri, IsEndpoint: true);
 
         public static readonly Parameter PageSizeHint = new("pageSizeHint", $"The number of items per {typeof(Page<>):C} that should be requested (from service operations that support it). It's not guaranteed that the value will be respected.", new CSharpType(typeof(int), true), null, ValidationType.None, null);
         public static readonly Parameter NextLink = new("nextLink", $"Continuation token", typeof(string), null, ValidationType.None, null);

src/AutoRest.CSharp/Common/Output/Models/Shared/Parameter.cs

@@ -16,7 +16,7 @@
 
 namespace AutoRest.CSharp.Output.Models.Shared
 {
-    internal record Parameter(string Name, FormattableString? Description, CSharpType Type, Constant? DefaultValue, ValidationType Validation, FormattableString? Initializer, bool IsApiVersionParameter = false, bool IsResourceIdentifier = false, bool SkipUrlEncoding = false, RequestLocation RequestLocation = RequestLocation.None, SerializationFormat SerializationFormat = SerializationFormat.Default, bool IsPropertyBag = false)
+    internal record Parameter(string Name, FormattableString? Description, CSharpType Type, Constant? DefaultValue, ValidationType Validation, FormattableString? Initializer, bool IsApiVersionParameter = false, bool IsEndpoint = false, bool IsResourceIdentifier = false, bool SkipUrlEncoding = false, RequestLocation RequestLocation = RequestLocation.None, SerializationFormat SerializationFormat = SerializationFormat.Default, bool IsPropertyBag = false)
     {
         public CSharpAttribute[] Attributes { get; init; } = Array.Empty<CSharpAttribute>();
         public bool IsOptionalInSignature => DefaultValue != null;
@@ -74,6 +74,7 @@ public static Parameter FromInputParameter(in InputParameter operationParameter,
                 validation,
                 initializer,
                 IsApiVersionParameter: operationParameter.IsApiVersion,
+                IsEndpoint: operationParameter.IsEndpoint,
                 IsResourceIdentifier: operationParameter.IsResourceParameter,
                 SkipUrlEncoding: skipUrlEncoding,
                 RequestLocation: requestLocation,
@@ -82,6 +83,7 @@ public static Parameter FromInputParameter(in InputParameter operationParameter,
 
         private static Constant? GetDefaultValue(InputParameter operationParameter, TypeFactory typeFactory) => operationParameter switch
         {
+            { Name: "$host", DefaultValue.Value: ""} => (Constant?)null, // In M4, when endpoint is not set, its default value is an empty string instead of null
             { NameInRequest: var nameInRequest } when RequestHeader.ClientRequestIdHeaders.Contains(nameInRequest) => Constant.FromExpression($"message.{Configuration.ApiTypes.HttpMessageRequestName}.ClientRequestId", new CSharpType(typeof(string))),
             { NameInRequest: var nameInRequest } when RequestHeader.ReturnClientRequestIdResponseHeaders.Contains(nameInRequest) => new Constant("true", new CSharpType(typeof(string))),
             { DefaultValue: not null } => BuilderHelpers.ParseConstant(operationParameter.DefaultValue.Value, typeFactory.CreateType(operationParameter.DefaultValue.Type)),
@@ -167,6 +169,7 @@ public static Parameter FromRequestParameter(in RequestParameter requestParamete
                 validation,
                 initializer,
                 IsApiVersionParameter: requestParameter.Origin == "modelerfour:synthesized/api-version",
+                IsEndpoint: IsEndpointParameter(requestParameter),
                 IsResourceIdentifier: requestParameter.IsResourceParameter,
                 SkipUrlEncoding: skipUrlEncoding,
                 RequestLocation: requestLocation);

src/AutoRest.CSharp/Common/Output/Models/Types/ClientOptionsTypeProvider.cs

@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Text;
 using AutoRest.CSharp.Input.Source;
+using AutoRest.CSharp.Output.Models.Shared;
 
 namespace AutoRest.CSharp.Output.Models.Types
 {
@@ -16,6 +17,7 @@ internal sealed class ClientOptionsTypeProvider : TypeProvider
 
         public FormattableString Description { get; }
         public IReadOnlyList<ApiVersion>? ApiVersions { get; }
+        public IReadOnlyList<Parameter> AdditionalParameters { get; init; }
         protected override string DefaultName { get; }
         protected override string DefaultAccessibility { get; }
 
@@ -27,6 +29,8 @@ public ClientOptionsTypeProvider(IReadOnlyList<string>? versions, string name, s
 
             if (versions is not null)
                 ApiVersions = ConvertApiVersions(versions);
+
+            AdditionalParameters = Array.Empty<Parameter>();
         }
 
         private static ApiVersion[] ConvertApiVersions(IReadOnlyList<string> versions) =>

src/AutoRest.CSharp/LowLevel/Generation/DpgClientWriter.cs

@@ -259,6 +259,10 @@ private void WritePrimaryPublicConstructor(ConstructorSignature signature)
                         {
                             _writer.Line($"{field.Name:I} = {clientOptionsParameter.Name:I}.Version;");
                         }
+                        else if (_client.ClientOptions.AdditionalParameters.Contains(parameter))
+                        {
+                            _writer.Line($"{field.Name:I} = {clientOptionsParameter.Name:I}.{parameter.Name.ToCleanName()};");
+                        }
                         else
                         {
                             _writer.Line($"{field.Name:I} = {parameter.Name:I};");

src/AutoRest.CSharp/LowLevel/Output/DpgOutputLibraryBuilder.cs

@@ -11,6 +11,7 @@
 using AutoRest.CSharp.Generation.Types;
 using AutoRest.CSharp.Input.Source;
 using AutoRest.CSharp.Output.Builders;
+using AutoRest.CSharp.Output.Models.Shared;
 using AutoRest.CSharp.Output.Models.Types;
 using AutoRest.CSharp.Utilities;
 using Microsoft.CodeAnalysis;
@@ -44,7 +45,8 @@ public DpgOutputLibrary Build(bool isTspInput)
                 .ToDictionary(ci => ci.Name);
             AssignParentClients(inputClients, clientInfosByName);
             var topLevelClientInfos = SetHierarchy(clientInfosByName);
-            var clientOptions = CreateClientOptions(topLevelClientInfos);
+            var parametersInClientOptions = new List<Parameter>();
+            var clientOptions = CreateClientOptions(topLevelClientInfos, parametersInClientOptions);
 
             SetRequestsToClients(clientInfosByName.Values);
 
@@ -59,7 +61,7 @@ public DpgOutputLibrary Build(bool isTspInput)
                 CreateModels(models, library.TypeFactory);
                 CreateEnums(enums, models, library.TypeFactory);
             }
-            CreateClients(clients, topLevelClientInfos, library.TypeFactory, clientOptions);
+            CreateClients(clients, topLevelClientInfos, library.TypeFactory, clientOptions, parametersInClientOptions);
 
             return library;
         }
@@ -459,7 +461,7 @@ private static IReadOnlyList<InputParameter> UpdateOperationParameters(IReadOnly
             return parameters;
         }
 
-        private ClientOptionsTypeProvider CreateClientOptions(IReadOnlyList<ClientInfo> topLevelClientInfos)
+        private ClientOptionsTypeProvider CreateClientOptions(IReadOnlyList<ClientInfo> topLevelClientInfos, List<Parameter> parametersInClientOptions)
         {
             var clientName = topLevelClientInfos.Count == 1
                 ? topLevelClientInfos[0].Name
@@ -477,7 +479,10 @@ private ClientOptionsTypeProvider CreateClientOptions(IReadOnlyList<ClientInfo>
                     throw new InvalidOperationException("Multiple API versions are not supported in the unbranded path.");
                 apiVersions = null;
             }
-            return new ClientOptionsTypeProvider(apiVersions, clientOptionsName, _defaultNamespace, description, _sourceInputModel);
+            return new ClientOptionsTypeProvider(apiVersions, clientOptionsName, _defaultNamespace, description, _sourceInputModel)
+            {
+                AdditionalParameters = parametersInClientOptions
+            };
         }
 
         private static ClientInfo CreateClientInfo(InputClient ns, SourceInputModel? sourceInputModel, string rootNamespaceName)
@@ -626,9 +631,9 @@ private static void SetRequestToClient(ClientInfo clientInfo, InputOperation ope
             clientInfo.Requests.Add(operation);
         }
 
-        private void CreateClients(List<LowLevelClient> allClients, IEnumerable<ClientInfo> topLevelClientInfos, TypeFactory typeFactory, ClientOptionsTypeProvider clientOptions)
+        private void CreateClients(List<LowLevelClient> allClients, IEnumerable<ClientInfo> topLevelClientInfos, TypeFactory typeFactory, ClientOptionsTypeProvider clientOptions, List<Parameter> parametersInClientOptions)
         {
-            var topLevelClients = CreateClients(topLevelClientInfos, typeFactory, clientOptions, null);
+            var topLevelClients = CreateClients(topLevelClientInfos, typeFactory, clientOptions, null, parametersInClientOptions);
 
             // Simple implementation of breadth first traversal
             allClients.AddRange(topLevelClients);
@@ -638,7 +643,7 @@ private void CreateClients(List<LowLevelClient> allClients, IEnumerable<ClientIn
             }
         }
 
-        private IEnumerable<LowLevelClient> CreateClients(IEnumerable<ClientInfo> clientInfos, TypeFactory typeFactory, ClientOptionsTypeProvider clientOptions, LowLevelClient? parentClient)
+        private IEnumerable<LowLevelClient> CreateClients(IEnumerable<ClientInfo> clientInfos, TypeFactory typeFactory, ClientOptionsTypeProvider clientOptions, LowLevelClient? parentClient, List<Parameter> parametersInClientOptions)
         {
             foreach (var clientInfo in clientInfos)
             {
@@ -673,7 +678,9 @@ private IEnumerable<LowLevelClient> CreateClients(IEnumerable<ClientInfo> client
                     SubClients = subClients
                 };
 
-                subClients.AddRange(CreateClients(clientInfo.Children, typeFactory, clientOptions, client));
+                subClients.AddRange(CreateClients(clientInfo.Children, typeFactory, clientOptions, client, parametersInClientOptions));
+                // parametersInClientOptions is assigned to ClientOptionsTypeProvider.AdditionalProperties before, which makes sure AdditionalProperties is readonly and won't change after ClientOptionsTypeProvider is built.
+                parametersInClientOptions.AddRange(client.GetOptionalParametersInOptions());
 
                 yield return client;
             }

src/AutoRest.CSharp/LowLevel/Output/LowLevelClient.cs

@@ -140,7 +140,7 @@ public static IEnumerable<LowLevelClientMethod> BuildMethods(LowLevelClient? cli
             if (!IsSubClient)
             {
                 var requiredParameters = RestClientBuilder.GetRequiredParameters(orderedParameters).ToArray();
-                var optionalParameters = RestClientBuilder.GetOptionalParameters(orderedParameters).Append(CreateOptionsParameter()).ToArray();
+                var optionalParameters = GetOptionalParametersInConstructor(RestClientBuilder.GetOptionalParameters(orderedParameters).Append(CreateOptionsParameter())).ToArray();
 
                 return (
                     BuildPrimaryConstructors(requiredParameters, optionalParameters).ToArray(),
@@ -153,6 +153,17 @@ public static IEnumerable<LowLevelClientMethod> BuildMethods(LowLevelClient? cli
             }
         }
 
+        private IEnumerable<Parameter> GetOptionalParametersInConstructor(IEnumerable<Parameter> optionalParameters)
+        {
+            return optionalParameters.Where(
+                p => ClientOptions.Type.EqualsIgnoreNullable(p.Type) || p.IsEndpoint); // Endpoint is an exception, even it is optional, still need to be the parameter of constructor
+        }
+
+        public IEnumerable<Parameter> GetOptionalParametersInOptions()
+        {
+            return RestClientBuilder.GetOptionalParameters(Parameters).Where(p => !p.IsEndpoint);
+        }
+
         private IEnumerable<ConstructorSignature> BuildPrimaryConstructors(IReadOnlyList<Parameter> requiredParameters, IReadOnlyList<Parameter> optionalParameters)
         {
             var optionalToRequired = optionalParameters