Update rest client and serialization generation for Azure plugin

eng/Packages.Data.props

@@ -252,7 +252,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(IsGeneratorLibrary)' == 'true'">
-    <PackageReference Update="Microsoft.Generator.CSharp.ClientModel" Version="1.0.0-alpha.20241022.3" />
+    <PackageReference Update="Microsoft.Generator.CSharp.ClientModel" Version="1.0.0-alpha.20241030.4" />
   </ItemGroup>
 
   <!--

eng/packages/http-client-csharp/generator/Azure.Generator/src/Providers/Abstraction/HttpMessageProvider.cs

@@ -21,9 +21,6 @@ public HttpMessageProvider(ValueExpression original) : base(typeof(HttpMessage),
 
         public override CSharpType HttpMessageType => typeof(HttpMessage);
 
-        public override MethodBodyStatement Apply(ValueExpression options)
-            => MethodBodyStatement.Empty;
-
         public override ValueExpression BufferResponse()
             => Original.Property(nameof(HttpMessage.BufferResponse));
 
@@ -39,9 +36,12 @@ public override HttpRequestApi Request()
         public override HttpResponseApi Response()
             => new AzureResponseProvider(Original.Property(nameof(HttpMessage.Response)));
 
-        public override ValueExpression ResponseClassifier()
-            => Original.Property(nameof(HttpMessage.ResponseClassifier));
-
         public override HttpMessageApi ToExpression() => this;
+
+        public override MethodBodyStatement ApplyResponseClassifier(StatusCodeClassifierApi statusCodeClassifier)
+            => MethodBodyStatement.Empty;
+
+        public override MethodBodyStatement ApplyRequestOptions(HttpRequestOptionsApi options)
+            => MethodBodyStatement.Empty;
     }
 }

eng/packages/http-client-csharp/generator/Azure.Generator/src/Providers/Abstraction/HttpPipelineProvider.cs

@@ -6,6 +6,7 @@
 using Microsoft.Generator.CSharp.ClientModel.Providers;
 using Microsoft.Generator.CSharp.Expressions;
 using Microsoft.Generator.CSharp.Primitives;
+using Microsoft.Generator.CSharp.Statements;
 using static Microsoft.Generator.CSharp.Snippets.Snippet;
 
 namespace Azure.Generator.Providers.Abstraction
@@ -28,9 +29,6 @@ public HttpPipelineProvider(ValueExpression original) : base(typeof(HttpPipeline
         public override ValueExpression Create(ValueExpression options, ValueExpression perRetryPolicies)
             => Static(typeof(HttpPipelineBuilder)).Invoke(nameof(HttpPipelineBuilder.Build), [options, perRetryPolicies]);
 
-        public override HttpMessageApi CreateMessage()
-            => new HttpMessageProvider(Original.Invoke(nameof(HttpPipeline.CreateMessage)));
-
         public override ValueExpression CreateMessage(HttpRequestOptionsApi requestOptions, ValueExpression responseClassifier)
             => Original.Invoke(nameof(HttpPipeline.CreateMessage), requestOptions, responseClassifier).As<HttpMessage>();
 
@@ -40,12 +38,12 @@ public override ClientPipelineApi FromExpression(ValueExpression expression)
         public override ValueExpression PerRetryPolicy(params ValueExpression[] arguments)
             => Empty; // TODO: implement with default retry policy for Azure
 
-        public override InvokeMethodExpression Send(HttpMessageApi message)
-            => Original.Invoke(nameof(HttpPipeline.Send), [message, Default]);
+        public override ClientPipelineApi ToExpression() => this;
 
-        public override InvokeMethodExpression SendAsync(HttpMessageApi message)
-            => Original.Invoke(nameof(HttpPipeline.SendAsync), [message, Default], true);
+        public override MethodBodyStatement Send(HttpMessageApi message, HttpRequestOptionsApi options)
+            => Original.Invoke(nameof(HttpPipeline.Send), [message, options.Property(nameof(RequestContext.CancellationToken))]).Terminate();
 
-        public override ClientPipelineApi ToExpression() => this;
+        public override MethodBodyStatement SendAsync(HttpMessageApi message, HttpRequestOptionsApi options)
+            => Original.Invoke(nameof(HttpPipeline.SendAsync), [message, options.Property(nameof(RequestContext.CancellationToken))], true).Terminate();
     }
 }

eng/packages/http-client-csharp/generator/Azure.Generator/src/Providers/Abstraction/HttpRequestProvider.cs

@@ -4,7 +4,8 @@
 using Azure.Core;
 using Microsoft.Generator.CSharp.ClientModel.Providers;
 using Microsoft.Generator.CSharp.Expressions;
-using Microsoft.Generator.CSharp.Snippets;
+using Microsoft.Generator.CSharp.Statements;
+using System;
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using static Microsoft.Generator.CSharp.Snippets.Snippet;
@@ -26,15 +27,79 @@ public override ValueExpression Content()
         public override HttpRequestApi FromExpression(ValueExpression original)
             => new HttpRequestProvider(original);
 
-        public override InvokeMethodExpression SetHeaders(IReadOnlyList<ValueExpression> arguments)
-            => Original.Property(nameof(PipelineRequest.Headers)).Invoke(nameof(RequestHeaders.Add), arguments);
+        public override MethodBodyStatement SetHeaders(IReadOnlyList<ValueExpression> arguments)
+            => Original.Property(nameof(PipelineRequest.Headers)).Invoke(nameof(RequestHeaders.SetValue), arguments).Terminate();
 
-        public override AssignmentExpression SetMethod(string httpMethod)
-            => Original.Property(nameof(PipelineRequest.Method)).Assign(New.Instance(typeof(RequestMethod), [Literal(httpMethod)]));
+        public override MethodBodyStatement SetMethod(string httpMethod)
+            => Original.Property(nameof(PipelineRequest.Method)).Assign(CreateRequestMethod(httpMethod)).Terminate();
 
-        public override AssignmentExpression SetUri(ValueExpression value)
-            => Original.Property("Uri").Assign(value);
+        public override MethodBodyStatement SetUri(ValueExpression value)
+            => Original.Property("Uri").Assign(value).Terminate();
 
         public override HttpRequestApi ToExpression() => this;
+
+        private ValueExpression CreateRequestMethod(string httpMethod)
+        {
+            var httpMethodString = ParseHttpMethodString(httpMethod);
+            return httpMethodString is null
+                ? New.Instance(typeof(RequestMethod), [Literal(httpMethod)])
+                : Static<RequestMethod>().Property(httpMethodString);
+        }
+
+        private string? ParseHttpMethodString(string method)
+        {
+            if (method == null)
+            {
+                throw new ArgumentNullException(nameof(method));
+            }
+            if (method.Length == 3)
+            {
+                if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Get";
+                }
+
+                if (string.Equals(method, "PUT", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Put";
+                }
+            }
+            else if (method.Length == 4)
+            {
+                if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Post";
+                }
+
+                if (string.Equals(method, "HEAD", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Head";
+                }
+            }
+            else
+            {
+                if (string.Equals(method, "PATCH", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Patch";
+                }
+
+                if (string.Equals(method, "DELETE", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Delete";
+                }
+
+                if (string.Equals(method, "OPTIONS", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Options";
+                }
+
+                if (string.Equals(method, "TRACE", StringComparison.OrdinalIgnoreCase))
+                {
+                    return "Trace";
+                }
+            }
+
+            return null;
+        }
     }
 }