[http-client-csharp] Add ArgumentExpression for ref/out argument support

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

@@ -1173,7 +1173,7 @@ protected override ScmMethodProvider[] BuildMethods()
                     continue;
                 }
 
-                var cachedClientFieldVar = new VariableExpression(subClient.Type, subClient._clientCachingField.Declaration, IsRef: true);
+                var cachedClientFieldVar = new VariableExpression(subClient.Type, subClient._clientCachingField.Declaration).AsArgument(isRef: true);
                 List<ValueExpression> subClientConstructorArgs = new(3);
                 List<ParameterProvider> accessorMethodParams = [];
 
@@ -1734,6 +1734,9 @@ private static void UpdateProtocolMethodInvocation(
                 case KeywordExpression keywordExpr when keywordExpr.Expression != null:
                     UpdateProtocolMethodInvocation(keywordExpr.Expression, originalSignature, updatedSignature);
                     break;
+                case ArgumentExpression argumentExpr:
+                    UpdateProtocolMethodInvocation(argumentExpr.Expression, originalSignature, updatedSignature);
+                    break;
             }
         }
 

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

@@ -419,7 +419,7 @@ private MethodBodyStatement[] BuildCollectionIfStatements(
                         statements.Add(new IfStatement(ReadOnlySpanSnippets.IsEmpty(currentSlice))
                         {
                             Return(new InvokeMethodExpression(null, tryResolveMethodName,
-                                [new VariableExpression(valueVar.Type, valueVar.Declaration, IsOut: true)]))
+                                [new ArgumentExpression(valueVar, IsOut: true)]))
                         });
                     }
 

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

@@ -508,7 +508,10 @@ private ConstructorProvider BuildMultipartFileOverload(
                 type: _jsonPatchFieldType,
                 name: JsonPatchPropertyName,
                 isRef: isRef,
-                body: new ExpressionPropertyBody(new VariableExpression(JsonPatchField.Type, JsonPatchField.Declaration, IsRef: isRef)),
+                body: new ExpressionPropertyBody(
+                    isRef
+                        ? ByRef(new VariableExpression(JsonPatchField.Type, JsonPatchField.Declaration))
+                        : new VariableExpression(JsonPatchField.Type, JsonPatchField.Declaration)),
                 attributes:
                 [
                     new AttributeStatement(typeof(JsonIgnoreAttribute)),

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Snippets/JsonPatchSnippets.cs

@@ -34,7 +34,7 @@ public static ScopedApi<bool> TryGetEncodedValue(
             this ScopedApi<JsonPatch> patch,
             ValueExpression jsonPath,
             VariableExpression encodedValue)
-        => patch.Invoke(nameof(JsonPatch.TryGetEncodedValue), [jsonPath, new VariableExpression(encodedValue.Type, encodedValue.Declaration, IsOut: true)]).As<bool>();
+        => patch.Invoke(nameof(JsonPatch.TryGetEncodedValue), [jsonPath, encodedValue.AsArgument(isOut: true)]).As<bool>();
 
         public static ScopedApi<bool> Contains(
             this ScopedApi<JsonPatch> patch,

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Expressions/ArgumentExpression.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.TypeSpec.Generator.Providers;
+
+namespace Microsoft.TypeSpec.Generator.Expressions
+{
+    /// <summary>
+    /// Represents a method argument that wraps a <see cref="ValueExpression"/> with optional <c>ref</c> or <c>out</c> modifiers.
+    /// </summary>
+    public sealed record ArgumentExpression(ValueExpression Expression, bool IsRef = false, bool IsOut = false) : ValueExpression
+    {
+        public ValueExpression Expression { get; private set; } = Expression;
+        public bool IsRef { get; private set; } = IsRef;
+        public bool IsOut { get; private set; } = IsOut;
+
+        internal override void Write(CodeWriter writer)
+        {
+            writer.AppendRawIf("ref ", IsRef);
+            writer.AppendRawIf("out ", IsOut);
+            Expression.Write(writer);
+        }
+
+        internal override ValueExpression? Accept(LibraryVisitor visitor, MethodProvider method)
+        {
+            var expr = visitor.VisitArgumentExpression(this, method);
+
+            if (expr is not ArgumentExpression argumentExpression)
+            {
+                return expr?.Accept(visitor, method);
+            }
+
+            var newExpression = argumentExpression.Expression.Accept(visitor, method);
+            if (newExpression != null)
+            {
+                argumentExpression.Expression = newExpression;
+            }
+
+            return argumentExpression;
+        }
+
+        public void Update(ValueExpression? expression = null, bool? isRef = null, bool? isOut = null)
+        {
+            if (expression != null)
+            {
+                Expression = expression;
+            }
+
+            if (isRef != null)
+            {
+                IsRef = isRef.Value;
+            }
+
+            if (isOut != null)
+            {
+                IsOut = isOut.Value;
+            }
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Expressions/VariableExpression.cs

@@ -6,21 +6,18 @@
 
 namespace Microsoft.TypeSpec.Generator.Expressions
 {
-    public record VariableExpression(CSharpType Type, CodeWriterDeclaration Declaration, bool IsRef = false, bool IsOut = false) : ValueExpression
+    public record VariableExpression(CSharpType Type, CodeWriterDeclaration Declaration) : ValueExpression
     {
         public CSharpType Type { get; private set; } = Type;
         public CodeWriterDeclaration Declaration { get; private set; } = Declaration;
-        public bool IsRef { get; private set; } = IsRef;
-        public bool IsOut { get; private set; } = IsOut;
-        public VariableExpression(CSharpType type, string name, bool isRef = false, bool isOut = false)
-            : this(type, new CodeWriterDeclaration(name), isRef, isOut)
+
+        public VariableExpression(CSharpType type, string name)
+            : this(type, new CodeWriterDeclaration(name))
         {
         }
 
         internal override void Write(CodeWriter writer)
         {
-            writer.AppendRawIf("ref ", IsRef);
-            writer.AppendRawIf("out ", IsOut);
             writer.Append(Declaration);
         }
 
@@ -29,7 +26,7 @@ internal override VariableExpression Accept(LibraryVisitor visitor, MethodProvid
             return visitor.VisitVariableExpression(this, method);
         }
 
-        public void Update(CSharpType? type = null, string? name = null, bool? isRef = null, bool? isOut = null)
+        public void Update(CSharpType? type = null, string? name = null)
         {
             if (type != null)
             {
@@ -39,14 +36,6 @@ public void Update(CSharpType? type = null, string? name = null, bool? isRef = n
             {
                 Declaration = new CodeWriterDeclaration(name);
             }
-            if (isRef != null)
-            {
-                IsRef = isRef.Value;
-            }
-            if (isOut != null)
-            {
-                IsOut = isOut.Value;
-            }
         }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/LibraryVisitor.cs

@@ -265,6 +265,11 @@ protected internal virtual void VisitLibrary(OutputLibrary library)
             return expression;
         }
 
+        protected internal virtual ValueExpression? VisitArgumentExpression(ArgumentExpression expression, MethodProvider method)
+        {
+            return expression;
+        }
+
         protected internal virtual VariableExpression VisitVariableExpression(VariableExpression expression, MethodProvider method)
         {
             return expression;

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

@@ -191,65 +191,35 @@ private string GetDebuggerDisplay()
         // TODO test case for changing the parameter name via the visitor to see if the variable expression is updated
         // Same for properties and fields
         // https://github.com/microsoft/typespec/issues/3813
-        public static implicit operator VariableExpression(ParameterProvider parameter) => GetVariableExpression(parameter, includeModifiers: false);
+        public static implicit operator VariableExpression(ParameterProvider parameter) => GetVariableExpression(parameter);
 
-        internal static VariableExpression GetVariableExpression(ParameterProvider parameter, bool includeModifiers)
+        internal static VariableExpression GetVariableExpression(ParameterProvider parameter)
         {
-            CodeWriterDeclaration? declaration = parameter._asVariable?.Declaration ?? parameter._asArgument?.Declaration;
-
-            var variableName = parameter.InputParameter?.IsExactName == true
-                ? parameter.Name
-                : parameter.Name.ToVariableName();
-
-            if (includeModifiers)
-            {
-                if (parameter._asArgument == null)
-                {
-                    if (declaration != null)
-                    {
-                        parameter._asArgument = new VariableExpression(
-                            parameter.Type,
-                            declaration,
-                            parameter.IsRef,
-                            parameter.IsOut);
-                    }
-                    else
-                    {
-                        parameter._asArgument = new VariableExpression(
-                            parameter.Type,
-                            variableName,
-                            parameter.IsRef,
-                            parameter.IsOut);
-                    }
-                }
-                return parameter._asArgument;
-            }
-
             if (parameter._asVariable == null)
             {
-                if (declaration != null)
-                {
-                    parameter._asVariable = new VariableExpression(
-                        parameter.Type,
-                        declaration,
-                        parameter.IsRef,
-                        parameter.IsOut);
-                }
-                else
-                {
-                    parameter._asVariable = new VariableExpression(
-                        parameter.Type,
-                        variableName,
-                        includeModifiers && parameter.IsRef,
-                        includeModifiers && parameter.IsOut);
-                }
+                var variableName = parameter.InputParameter?.IsExactName == true
+                    ? parameter.Name
+                    : parameter.Name.ToVariableName();
+
+                parameter._asVariable = new VariableExpression(
+                    parameter.Type,
+                    variableName);
             }
 
             return parameter._asVariable;
         }
 
+        internal static ValueExpression GetArgumentExpression(ParameterProvider parameter)
+        {
+            var variable = GetVariableExpression(parameter);
+            if (parameter.IsRef || parameter.IsOut)
+            {
+                return new ArgumentExpression(variable, parameter.IsRef, parameter.IsOut);
+            }
+            return variable;
+        }
+
         private VariableExpression? _asVariable;
-        private VariableExpression? _asArgument;
 
         public TypeProvider? SpreadSource { get; set; }
 
@@ -312,7 +282,6 @@ internal ParameterProvider WithRef()
                 validation: Validation)
             {
                 _asVariable = _asVariable,
-                _asArgument = _asArgument,
             };
         }
 
@@ -340,7 +309,6 @@ public void Update(
             {
                 Name = name;
                 _asVariable?.Update(name: name);
-                _asArgument?.Update(name: name);
             }
 
             if (description is not null)
@@ -362,15 +330,11 @@ public void Update(
             if (isRef is not null)
             {
                 IsRef = isRef.Value;
-                _asVariable?.Update(isRef: IsRef);
-                _asArgument?.Update(isRef: IsRef);
             }
 
             if (isOut is not null)
             {
                 IsOut = isOut.Value;
-                _asVariable?.Update(isOut: IsOut);
-                _asArgument?.Update(isOut: IsOut);
             }
 
             if (isIn is not null)

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Snippets/Snippet.cs

@@ -102,7 +102,7 @@ public static ValueExpression RemoveAllNullConditional(ValueExpression expressio
         public static MethodBodyStatement Return() => new KeywordExpression("return", null).Terminate();
         public static MethodBodyStatement Throw(ValueExpression? expression = default) => new KeywordExpression("throw", expression).Terminate();
 
-        public static ValueExpression ByRef(ValueExpression expression) => new KeywordExpression("ref", expression);
+        public static ValueExpression ByRef(ValueExpression expression) => new ArgumentExpression(expression, IsRef: true);
 
         public static ValueExpression ArrayEmpty(CSharpType arrayItemType)
             => Static<Array>().Invoke(nameof(Array.Empty), [], [arrayItemType], false);
@@ -179,7 +179,12 @@ public static ValueExpression Invoke(this PropertyProvider property,
         public static ScopedApi<bool> NotEqual(this ParameterProvider parameter, ValueExpression other)
             => new BinaryOperatorExpression("!=", parameter, other).As<bool>();
 
-        public static VariableExpression AsVariable(this ParameterProvider parameter) => ParameterProvider.GetVariableExpression(parameter, includeModifiers: false);
-        public static VariableExpression AsArgument(this ParameterProvider property) => ParameterProvider.GetVariableExpression(property, includeModifiers: true);
+        public static VariableExpression AsVariable(this ParameterProvider parameter) => ParameterProvider.GetVariableExpression(parameter);
+        public static ValueExpression AsArgument(this ParameterProvider parameter) => ParameterProvider.GetArgumentExpression(parameter);
+
+        /// <summary>
+        /// Wraps a <see cref="ValueExpression"/> as an argument with optional <c>ref</c> or <c>out</c> modifiers.
+        /// </summary>
+        public static ValueExpression AsArgument(this ValueExpression expression, bool isRef = false, bool isOut = false) => new ArgumentExpression(expression, isRef, isOut);
     }
 }