[http-client-csharp-mgmt] Generate tag related methods (Azure#50482)

Generate tag related methods in Resource Provider.

Author: haiyuazhang

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Extensions/ClientProviderExtensions.cs

@@ -14,5 +14,10 @@ public static MethodProvider GetConvenienceMethodByOperation(this ClientProvider
             var methods = clientProvider.GetMethodCollectionByOperation(operation);
             return isAsync ? methods[^1] : methods[^2];
         }
+
+        public static MethodProvider GetRequestMethodByOperation(this ClientProvider clientProvider, InputOperation operation)
+        {
+            return clientProvider.RestClient.GetCreateRequestMethod(operation);
+        }
     }
 }

eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/ResourceOperationMethodProvider.cs

@@ -2,8 +2,9 @@
 // Licensed under the MIT License.
 
 using Azure.Core;
-using Azure.Core.Pipeline;
+using Azure.Generator.Management.Extensions;
 using Azure.Generator.Management.Primitives;
+using Azure.Generator.Management.Snippets;
 using Azure.Generator.Management.Utilities;
 using Azure.ResourceManager;
 using Microsoft.TypeSpec.Generator.Expressions;
@@ -58,14 +59,12 @@ public static implicit operator MethodProvider(ResourceOperationMethodProvider r
 
         protected virtual MethodBodyStatement[] BuildBodyStatements()
         {
-            var scopeDeclaration = BuildDiagnosticScopeDeclaration(out var scopeVariable);
-            return
-            [
-                scopeDeclaration,
-                scopeVariable.Invoke(nameof(DiagnosticScope.Start)).Terminate(),
+            var scopeStatements = ResourceMethodSnippets.CreateDiagnosticScopeStatements(_resourceClientProvider, _signature.Name, out var scopeVariable);
+            return [
+                .. scopeStatements,
                 new TryCatchFinallyStatement(
                     BuildTryExpression(),
-                    BuildCatchExpression(scopeVariable)
+                    ResourceMethodSnippets.CreateDiagnosticCatchBlock(scopeVariable)
                 )
             ];
         }
@@ -86,27 +85,22 @@ protected virtual MethodSignature CreateSignature()
                 _convenienceMethod.Signature.NonDocumentComment);
         }
 
-        private MethodBodyStatement BuildDiagnosticScopeDeclaration(out VariableExpression scopeVariable)
-        {
-            return UsingDeclare(
-                "scope",
-                typeof(DiagnosticScope),
-                _clientDiagnosticsField.Invoke(
-                    nameof(ClientDiagnostics.CreateScope),
-                    [Literal($"{_resourceClientProvider.Name}.{_signature.Name}")]),
-                out scopeVariable);
-        }
-
         private TryExpression BuildTryExpression()
         {
             var cancellationTokenParameter = _convenienceMethod.Signature.Parameters.Single(p => p.Type.Equals(typeof(CancellationToken)));
 
+            var requestMethod = _resourceClientProvider.GetClientProvider().GetRequestMethodByOperation(_serviceMethod.Operation);
+
             var tryStatements = new List<MethodBodyStatement>
             {
-                BuildRequestContextInitialization(cancellationTokenParameter, out var contextVariable),
-                BuildHttpMessageInitialization(contextVariable, out var messageVariable)
+                ResourceMethodSnippets.CreateRequestContext(cancellationTokenParameter, out var contextVariable)
             };
 
+            // Populate arguments for the REST client method call
+            var arguments = _resourceClientProvider.PopulateArguments(requestMethod.Signature.Parameters, contextVariable, _convenienceMethod);
+
+            tryStatements.Add(ResourceMethodSnippets.CreateHttpMessage(_resourceClientProvider, requestMethod.Signature.Name, arguments, out var messageVariable));
+
             tryStatements.AddRange(BuildClientPipelineProcessing(messageVariable, contextVariable, out var responseVariable));
 
             if (_serviceMethod.IsLongRunningOperation())
@@ -124,91 +118,33 @@ private TryExpression BuildTryExpression()
             return new TryExpression(tryStatements);
         }
 
-        private CatchExpression BuildCatchExpression(VariableExpression scopeVariable)
-        {
-            return Catch(
-                Declare<Exception>("e", out var exceptionVariable),
-                [
-                    scopeVariable.Invoke(nameof(DiagnosticScope.Failed), exceptionVariable).Terminate(),
-                    Throw()
-                ]);
-        }
-
-        private MethodBodyStatement BuildRequestContextInitialization(ParameterProvider cancellationTokenParameter, out VariableExpression contextVariable)
-        {
-            var requestContextParams = new Dictionary<ValueExpression, ValueExpression>
-            {
-                { Identifier(nameof(RequestContext.CancellationToken)), cancellationTokenParameter }
-            };
-            return Declare(
-                "context",
-                typeof(RequestContext),
-                New.Instance(typeof(RequestContext), requestContextParams),
-                out contextVariable);
-        }
-
-        private MethodBodyStatement BuildHttpMessageInitialization(VariableExpression contextVariable, out VariableExpression messageVariable)
-        {
-            var requestMethod = _serviceMethod.GetCorrespondingRequestMethod(_resourceClientProvider);
-
-            var arguments = PopulateArguments(
-                requestMethod.Signature.Parameters,
-                contextVariable);
-
-            var invokeExpression = _resourceClientProvider
-                .GetRestClientField()
-                .Invoke(requestMethod.Signature.Name, arguments);
-
-            return Declare(
-                "message",
-                typeof(HttpMessage),
-                invokeExpression,
-                out messageVariable);
-        }
-
         private IReadOnlyList<MethodBodyStatement> BuildClientPipelineProcessing(
             VariableExpression messageVariable,
             VariableExpression contextVariable,
             out VariableExpression responseVariable)
         {
-            var statements = new List<MethodBodyStatement>();
             var responseType = _convenienceMethod.Signature.ReturnType!.UnWrapAsync();
-            VariableExpression declaredResponseVariable;
-            var pipelineInvoke = _isAsync ? "ProcessMessageAsync" : "ProcessMessage";
 
+            // Check if the return type is a generic Response<T> or just Response
             if (!responseType.Equals(typeof(Response)))
             {
-                var resultDeclaration = Declare(
-                    "result",
-                    typeof(Response),
-                    Identifier("this")
-                        .Property("Pipeline")
-                        .Invoke(pipelineInvoke, [messageVariable, contextVariable], null, _isAsync),
-                    out var resultVariable);
-                statements.Add(resultDeclaration);
-
-                var responseDeclaration = Declare(
-                    "response",
+                // For methods returning Response<T> (e.g., Response<MyResource>), use generic response processing
+                return ResourceMethodSnippets.CreateGenericResponsePipelineProcessing(
+                    messageVariable,
+                    contextVariable,
                     responseType,
-                    Static(typeof(Response)).Invoke(
-                        nameof(Response.FromValue),
-                        [resultVariable.CastTo(responseType.Arguments[0]), resultVariable]),
-                    out declaredResponseVariable);
-                statements.Add(responseDeclaration);
+                    _isAsync,
+                    out responseVariable);
             }
             else
             {
-                var responseDeclaration = Declare(
-                    "response",
-                    typeof(Response),
-                    Identifier("this")
-                        .Property("Pipeline")
-                        .Invoke(pipelineInvoke, [messageVariable, contextVariable], null, _isAsync),
-                    out declaredResponseVariable);
-                statements.Add(responseDeclaration);
+                // For methods returning just Response (no generic type), use non-generic response processing
+                return ResourceMethodSnippets.CreateNonGenericResponsePipelineProcessing(
+                    messageVariable,
+                    contextVariable,
+                    _isAsync,
+                    out responseVariable);
             }
-            responseVariable = declaredResponseVariable;
-            return statements;
         }
 
         private IReadOnlyList<MethodBodyStatement> BuildLroHandling(
@@ -297,52 +233,6 @@ protected virtual IReadOnlyList<MethodBodyStatement> BuildReturnStatements(Value
             return statements;
         }
 
-        private ValueExpression[] PopulateArguments(
-            IReadOnlyList<ParameterProvider> parameters,
-            VariableExpression contextVariable)
-        {
-            var arguments = new List<ValueExpression>();
-            foreach (var parameter in parameters)
-            {
-                if (parameter.Name.Equals("subscriptionId", StringComparison.InvariantCultureIgnoreCase))
-                {
-                    arguments.Add(
-                        Static(typeof(Guid)).Invoke(
-                            nameof(Guid.Parse),
-                            This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.SubscriptionId))));
-                }
-                else if (parameter.Name.Equals("resourceGroupName", StringComparison.InvariantCultureIgnoreCase))
-                {
-                    arguments.Add(
-                        This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.ResourceGroupName)));
-                }
-                // TODO: handle parents
-                // Handle resource name - the last contextual parameter
-                else if (parameter.Name.Equals(_resourceClientProvider.ContextualParameters.Last(), StringComparison.InvariantCultureIgnoreCase))
-                {
-                    arguments.Add(
-                        This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.Name)));
-                }
-                else if (parameter.Type.Equals(typeof(RequestContent)))
-                {
-                    var resource = _convenienceMethod.Signature.Parameters
-                        .Single(p => p.Type.Equals(_resourceClientProvider.ResourceData.Type));
-                    arguments.Add(resource);
-                }
-                else if (parameter.Type.Equals(typeof(RequestContext)))
-                {
-                    var cancellationToken = _convenienceMethod.Signature.Parameters
-                        .Single(p => p.Type.Equals(typeof(CancellationToken)));
-                    arguments.Add(contextVariable);
-                }
-                else
-                {
-                    arguments.Add(parameter);
-                }
-            }
-            return [.. arguments];
-        }
-
         protected IReadOnlyList<ParameterProvider> GetOperationMethodParameters()
         {
             var result = new List<ParameterProvider>();

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

@@ -5,9 +5,9 @@
 using Azure.Core.Pipeline;
 using Azure.Generator.Management.Extensions;
 using Azure.Generator.Management.Models;
-using Azure.Generator.Management.Primitives;
 using Azure.Generator.Management.Providers.OperationMethodProviders;
 using Azure.Generator.Management.Snippets;
+using Azure.Generator.Management.Providers.TagMethodProviders;
 using Azure.Generator.Management.Utilities;
 using Azure.ResourceManager;
 using Microsoft.TypeSpec.Generator.ClientModel.Providers;
@@ -102,6 +102,7 @@ private IReadOnlyList<string> GetContextualParameters(string contextualRequestPa
 
         internal ModelProvider ResourceData { get; }
         internal string SpecName { get; }
+        internal IReadOnlyCollection<InputServiceMethod> ResourceServiceMethods => _resourceServiceMethods;
 
         public bool IsSingleton { get; }
 
@@ -195,6 +196,7 @@ protected ConstructorProvider BuildResourceIdentifierConstructor()
         }
 
         internal const string ValidateResourceIdMethodName = "ValidateResourceId";
+
         protected MethodProvider BuildValidateResourceIdMethod()
         {
             var idParameter = new ParameterProvider("id", $"", typeof(ResourceIdentifier));
@@ -265,7 +267,17 @@ protected override MethodProvider[] BuildMethods()
                 }
             }
 
-            return [BuildValidateResourceIdMethod(), .. operationMethods];
+            return [
+                BuildValidateResourceIdMethod(),
+                .. operationMethods,
+                new AddTagMethodProvider(this, true),
+                new AddTagMethodProvider(this, false),
+                // Disabled SetTag methods generation temporarily: The extension method ReplaceWith for IDictionary<string, string> is defined in SharedExtensions.cs, which is not included in the project yet.
+                // new SetTagsMethodProvider(this, true),
+                // new SetTagsMethodProvider(this, false),
+                new RemoveTagMethodProvider(this, true),
+                new RemoveTagMethodProvider(this, false)
+            ];
         }
 
         protected MethodProvider BuildOperationMethod(InputServiceMethod method, MethodProvider convenienceMethod, bool isAsync)
@@ -289,5 +301,59 @@ public ScopedApi<bool> TryGetApiVersion(out ScopedApi<string> apiVersion)
             var invocation = new InvokeMethodExpression(This, "TryGetApiVersion", [ResourceTypeExpression, new DeclarationExpression(apiVersionDeclaration, true)]);
             return invocation.As<bool>();
         }
+
+        public ValueExpression[] PopulateArguments(
+            IReadOnlyList<ParameterProvider> parameters,
+            VariableExpression contextVariable,
+            MethodProvider? convenienceMethod = null)
+        {
+            var arguments = new List<ValueExpression>();
+            foreach (var parameter in parameters)
+            {
+                if (parameter.Name.Equals("subscriptionId", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    arguments.Add(
+                        Static(typeof(Guid)).Invoke(
+                            nameof(Guid.Parse),
+                            This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.SubscriptionId))));
+                }
+                else if (parameter.Name.Equals("resourceGroupName", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    arguments.Add(
+                        This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.ResourceGroupName)));
+                }
+                // TODO: handle parents
+                // Handle resource name - the last contextual parameter
+                else if (parameter.Name.Equals(ContextualParameters.Last(), StringComparison.InvariantCultureIgnoreCase))
+                {
+                    arguments.Add(
+                        This.Property(nameof(ArmResource.Id)).Property(nameof(ResourceIdentifier.Name)));
+                }
+                else if (parameter.Type.Equals(typeof(RequestContent)))
+                {
+                    // If convenience method is provided, find the resource parameter from it
+                    if (convenienceMethod != null)
+                    {
+                        var resource = convenienceMethod.Signature.Parameters
+                            .Single(p => p.Type.Equals(ResourceData.Type));
+                        arguments.Add(resource);
+                    }
+                    else
+                    {
+                        // Otherwise just add the parameter as-is
+                        arguments.Add(parameter);
+                    }
+                }
+                else if (parameter.Type.Equals(typeof(RequestContext)))
+                {
+                    arguments.Add(contextVariable);
+                }
+                else
+                {
+                    arguments.Add(parameter);
+                }
+            }
+            return [.. arguments];
+        }
     }
 }