[httpclient-chsharp-mgmt] implement resourceCollectionClientProvider (Azure#49831)

* first commit.

* add readonly modifier.

* refine.

* remove useless using statement.

* address Wei's review comments.

* small refine.

* add one more todo.

* address code review comments.

* fix rebase issue.

* add unit tests for ResourceCollectionClientProvider.

Author: haiyuazhang

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Mgmt/src/Providers/ResourceClientProvider.cs

@@ -32,7 +32,6 @@ namespace Azure.Generator.Management.Providers
     internal class ResourceClientProvider : TypeProvider
     {
         private IReadOnlyCollection<InputServiceMethod> _resourceServiceMethods;
-        private readonly IReadOnlyList<string> _contextualParameters;
 
         private FieldProvider _dataField;
         private FieldProvider _resourcetypeField;
@@ -56,11 +55,11 @@ public ResourceClientProvider(InputClient inputClient)
             ResourceData = ManagementClientGenerator.Instance.TypeFactory.CreateModel(resourceModel)!;
             _clientProvider = ManagementClientGenerator.Instance.TypeFactory.CreateClient(inputClient)!;
 
-            _contextualParameters = GetContextualParameters(requestPath);
+            ContextualParameters = GetContextualParameters(requestPath);
 
-            _dataField = new FieldProvider(FieldModifiers.Private, ResourceData.Type, "_data", this);
-            _clientDiagonosticsField = new FieldProvider(FieldModifiers.Private, typeof(ClientDiagnostics), $"_{SpecName.ToLower()}ClientDiagnostics", this);
-            _restClientField = new FieldProvider(FieldModifiers.Private, _clientProvider.Type, $"_{SpecName.ToLower()}RestClient", this);
+            _dataField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, ResourceData.Type, "_data", this);
+            _clientDiagonosticsField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, typeof(ClientDiagnostics), $"_{SpecName.ToLower()}ClientDiagnostics", this);
+            _restClientField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, _clientProvider.Type, $"_{SpecName.ToLower()}RestClient", this);
         }
 
         private IReadOnlyList<string> GetContextualParameters(string contextualRequestPath)
@@ -77,6 +76,8 @@ private IReadOnlyList<string> GetContextualParameters(string contextualRequestPa
             return contextualParameters;
         }
 
+        protected IReadOnlyList<string> ContextualParameters { get; }
+
         protected override string BuildName() => $"{SpecName}Resource";
 
         private OperationSourceProvider? _source;
@@ -89,7 +90,7 @@ private IReadOnlyList<string> GetContextualParameters(string contextualRequestPa
 
         protected override string BuildRelativeFilePath() => Path.Combine("src", "Generated", $"{Name}.cs");
 
-        protected override FieldProvider[] BuildFields() => [_dataField, _clientDiagonosticsField, _restClientField, _resourcetypeField];
+        protected override FieldProvider[] BuildFields() => [_clientDiagonosticsField, _restClientField, _dataField, _resourcetypeField];
 
         protected override PropertyProvider[] BuildProperties()
         {
@@ -199,6 +200,8 @@ protected MethodProvider BuildValidateResourceIdMethod()
 
         protected virtual ValueExpression ExpectedResourceTypeForValidation => _resourcetypeField;
 
+        protected virtual CSharpType ResourceClientCharpType => this.Type;
+
         protected override CSharpType[] BuildImplements() => [typeof(ArmResource)];
 
         protected override MethodProvider[] BuildMethods()
@@ -224,14 +227,14 @@ protected override MethodProvider[] BuildMethods()
             return [BuildValidateResourceIdMethod(), .. operationMethods];
         }
 
-        private MethodProvider BuildOperationMethod(InputServiceMethod method, MethodProvider convenienceMethod, bool isAsync, bool isUpdateOnly = false)
+        // TODO: the BuildOperationMethod related code is kind of messy now need to be refactored in a following up PR
+        protected MethodProvider BuildOperationMethod(InputServiceMethod method, MethodProvider convenienceMethod, bool isAsync, bool isUpdateOnly = false)
         {
-            var operation = method.Operation;
             var signature = new MethodSignature(
                 isUpdateOnly ? (isAsync ? "UpdateAsync" : "Update") : convenienceMethod.Signature.Name,
                 isUpdateOnly ? $"Update a {SpecName}" : convenienceMethod.Signature.Description,
                 convenienceMethod.Signature.Modifiers,
-                GetOperationMethodReturnType(isAsync, method is InputLongRunningServiceMethod || method is InputLongRunningPagingServiceMethod, operation.Responses, out var isGeneric),
+                GetOperationMethodReturnType(method, isAsync, out var isGeneric),
                 convenienceMethod.Signature.ReturnDescription,
                 GetOperationMethodParameters(convenienceMethod, method is InputLongRunningServiceMethod),
                 convenienceMethod.Signature.Attributes,
@@ -240,58 +243,85 @@ private MethodProvider BuildOperationMethod(InputServiceMethod method, MethodPro
                 convenienceMethod.Signature.ExplicitInterface,
                 convenienceMethod.Signature.NonDocumentComment);
 
+            return BuildOperationMethodCore(method, convenienceMethod, signature, isAsync, isGeneric);
+        }
+
+        protected MethodProvider BuildOperationMethodCore(InputServiceMethod method, MethodProvider convenienceMethod, MethodSignature signature, bool isAsync, bool isGeneric)
+        {
             var bodyStatements = new MethodBodyStatement[]
                 {
-                    UsingDeclare("scope", typeof(DiagnosticScope), _clientDiagonosticsField.Invoke(nameof(ClientDiagnostics.CreateScope), [Literal($"{Type.Namespace}.{operation.Name}")]), out var scopeVariable),
+                    UsingDeclare("scope", typeof(DiagnosticScope), _clientDiagonosticsField.Invoke(nameof(ClientDiagnostics.CreateScope), [Literal($"{Name}.{signature.Name}")]), out var scopeVariable),
                     scopeVariable.Invoke(nameof(DiagnosticScope.Start)).Terminate(),
                     new TryCatchFinallyStatement
-                    (BuildOperationMethodTryStatement(convenienceMethod, isAsync, method, isGeneric), Catch(Declare<Exception>("e", out var exceptionVarialble), [scopeVariable.Invoke(nameof(DiagnosticScope.Failed), exceptionVarialble).Terminate(), Throw()]))
+                    (BuildOperationMethodTryStatement(method, convenienceMethod, signature, isAsync, isGeneric),
+                     Catch(Declare<Exception>("e", out var exceptionVarialble),
+                     [scopeVariable.Invoke(nameof(DiagnosticScope.Failed), exceptionVarialble).Terminate(), Throw()]))
                 };
 
             return new MethodProvider(signature, bodyStatements, this);
         }
 
+        protected virtual bool SkipMethodParameter(ParameterProvider parameter)
+        {
+            return ContextualParameters.Contains(parameter.Name);
+        }
+
         protected IReadOnlyList<ParameterProvider> GetOperationMethodParameters(MethodProvider convenienceMethod, bool isLongRunning)
         {
             var result = new List<ParameterProvider>();
             if (isLongRunning)
             {
                 result.Add(KnownAzureParameters.WaitUntil);
             }
+
             foreach (var parameter in convenienceMethod.Signature.Parameters)
             {
-                if (!_contextualParameters.Contains(parameter.Name))
+                if (!SkipMethodParameter(parameter))
                 {
                     result.Add(parameter);
                 }
             }
+
             return result;
         }
 
-        protected CSharpType GetOperationMethodReturnType(bool isAsync, bool isLongRunningOperation, IReadOnlyList<InputOperationResponse> operationResponses, out bool isGeneric)
+        protected bool IsLongRunningOperation(InputServiceMethod method)
+        {
+            return method is InputLongRunningServiceMethod || method is InputLongRunningPagingServiceMethod;
+        }
+
+        protected bool IsReturnTypeGeneric(InputServiceMethod method)
+        {
+            var operationResponses = method.Operation.Responses;
+            var response = operationResponses.FirstOrDefault(r => !r.IsErrorResponse);
+            var responseBodyType = response?.BodyType is null ? null : ManagementClientGenerator.Instance.TypeFactory.CreateCSharpType(response.BodyType);
+            return IsLongRunningOperation(method) && responseBodyType is not null;
+        }
+
+        protected CSharpType GetOperationMethodReturnType(InputServiceMethod method, bool isAsync, out bool isGeneric)
         {
-            isGeneric = false;
+            bool isLongRunningOperation = IsLongRunningOperation(method);
+            isGeneric = IsReturnTypeGeneric(method);
+
             if (isLongRunningOperation)
             {
-                var response = operationResponses.FirstOrDefault(r => !r.IsErrorResponse);
-                var responseBodyType = response?.BodyType is null ? null : ManagementClientGenerator.Instance.TypeFactory.CreateCSharpType(response.BodyType);
-                if (responseBodyType is null)
+                if (!isGeneric)
                 {
                     return isAsync ? new CSharpType(typeof(Task<>), typeof(ArmOperation)) : typeof(ArmOperation);
                 }
                 else
                 {
-                    isGeneric = true;
-                    return isAsync ? new CSharpType(typeof(Task<>), new CSharpType(typeof(ArmOperation<>), Type)) : new CSharpType(typeof(ArmOperation<>), Type);
+                    return isAsync ? new CSharpType(typeof(Task<>), new CSharpType(typeof(ArmOperation<>), ResourceClientCharpType)) : new CSharpType(typeof(ArmOperation<>), ResourceClientCharpType);
                 }
             }
-            return isAsync ? new CSharpType(typeof(Task<>), new CSharpType(typeof(Response<>), Type)) : new CSharpType(typeof(Response<>), Type);
+            return isAsync ? new CSharpType(typeof(Task<>), new CSharpType(typeof(Response<>), ResourceClientCharpType)) : new CSharpType(typeof(Response<>), ResourceClientCharpType);
         }
 
-        private TryStatement BuildOperationMethodTryStatement(MethodProvider convenienceMethod, bool isAsync, InputServiceMethod method, bool isGeneric)
+        private TryStatement BuildOperationMethodTryStatement(InputServiceMethod method, MethodProvider convenienceMethod, MethodSignature signature, bool isAsync, bool isGeneric)
         {
             var operation = method.Operation;
             var cancellationToken = convenienceMethod.Signature.Parameters.Single(p => p.Type.Equals(typeof(CancellationToken)));
+
             var tryStatement = new TryStatement();
             var contextDeclaration = Declare("context", typeof(RequestContext), New.Instance(typeof(RequestContext), new Dictionary<ValueExpression, ValueExpression> { { Identifier(nameof(RequestContext.CancellationToken)), cancellationToken } }), out var contextVariable);
             tryStatement.Add(contextDeclaration);
@@ -325,7 +355,7 @@ private TryStatement BuildOperationMethodTryStatement(MethodProvider convenience
                     finalStateVia = (OperationFinalStateVia)lroPagingMethod.LongRunningServiceMetadata.FinalStateVia;
                 }
 
-                var armOperationType = !isGeneric ? ManagementClientGenerator.Instance.OutputLibrary.ArmOperation.Type : ManagementClientGenerator.Instance.OutputLibrary.GenericArmOperation.Type.MakeGenericType([Type]);
+                var armOperationType = !isGeneric ? ManagementClientGenerator.Instance.OutputLibrary.ArmOperation.Type : ManagementClientGenerator.Instance.OutputLibrary.GenericArmOperation.Type.MakeGenericType([ResourceClientCharpType]);
                 ValueExpression[] armOperationArguments = [_clientDiagonosticsField, This.Property("Pipeline"), messageVariable.Property("Request"), isGeneric ? responseVariable.Invoke("GetRawResponse") : responseVariable, Static(typeof(OperationFinalStateVia)).Property(finalStateVia.ToString())];
                 var operationDeclaration = Declare("operation", armOperationType, New.Instance(armOperationType, isGeneric ? [New.Instance(Source.Type, This.Property("Client")), .. armOperationArguments] : armOperationArguments), out var operationVariable);
 
@@ -340,15 +370,27 @@ private TryStatement BuildOperationMethodTryStatement(MethodProvider convenience
             }
             else
             {
-                tryStatement.Add(new IfStatement(responseVariable.Property("Value").Equal(Null))
-            {
-                ((KeywordExpression)ThrowExpression(New.Instance(typeof(RequestFailedException), responseVariable.Invoke("GetRawResponse")))).Terminate()
-            });
-                tryStatement.Add(Return(Static(typeof(Response)).Invoke(nameof(Response.FromValue), New.Instance(Type, This.Property("Client"), responseVariable.Property("Value")), responseVariable.Invoke("GetRawResponse"))));
+                tryStatement.Add(BuildReturnStatements(responseVariable, signature));
             }
+
             return tryStatement;
         }
 
+        protected virtual MethodBodyStatement BuildReturnStatements(ValueExpression responseVariable, MethodSignature signature)
+        {
+            List<MethodBodyStatement> statements =
+            [
+                new IfStatement(responseVariable.Property("Value").Equal(Null))
+                        {
+                            ((KeywordExpression)ThrowExpression(New.Instance(typeof(RequestFailedException), responseVariable.Invoke("GetRawResponse")))).Terminate()
+                        },
+            ];
+            var returnValueExpression =  New.Instance(ResourceClientCharpType, This.Property("Client"), responseVariable.Property("Value"));
+            statements.Add(Return(Static(typeof(Response)).Invoke(nameof(Response.FromValue), returnValueExpression, responseVariable.Invoke("GetRawResponse"))));
+
+            return statements;
+        }
+
         private static CSharpType GetResponseType(MethodProvider convenienceMethod, bool isAsync) => isAsync ? convenienceMethod.Signature.ReturnType?.Arguments[0]! : convenienceMethod.Signature.ReturnType!;
 
         private ValueExpression[] PopulateArguments(IReadOnlyList<ParameterProvider> parameters, MethodProvider convenienceMethod, VariableExpression contextVariable)
@@ -365,7 +407,7 @@ private ValueExpression[] PopulateArguments(IReadOnlyList<ParameterProvider> par
                     arguments.Add(This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.ResourceGroupName)));
                 }
                 // TODO: handle parents
-                else if (parameter.Name.Equals(_contextualParameters.Last(), StringComparison.InvariantCultureIgnoreCase))
+                else if (parameter.Name.Equals(ContextualParameters.Last(), StringComparison.InvariantCultureIgnoreCase))
                 {
                     arguments.Add(This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.Name)));
                 }