Improve out arguments assignability, for both validation and expression compilation (STUD-76892)

Author: gpanaitescu

src/UiPath.Workflow/Activities/Utils/CSharpCompilerHelper.cs

@@ -4,14 +4,11 @@
 using Microsoft.CodeAnalysis.Scripting.Hosting;
 using ReflectionMagic;
 using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
 
 namespace System.Activities
 {
     public sealed class CSharpCompilerHelper : CompilerHelper
     {
-        private static int crt = 0;
         private static readonly dynamic s_typeNameFormatter = GetTypeNameFormatter();
         private static readonly dynamic s_typeOptions = GetTypeOptions();
 
@@ -39,22 +36,19 @@ public override string CreateExpressionCode(string[] types, string[] names, stri
             return $"{myDelegate} \n public static Expression<{name}<{typesStr}>> CreateExpression() => ({namesStr}) => {code};";
         }
 
-        protected override (string, string) DefineDelegateCommon(int argumentsCount)
+        internal string CreateReferenceCode(string[] types, string returnType, string[] names, string code)
         {
-            var crtValue = Interlocked.Add(ref crt, 1);
-
-            var part1 = new StringBuilder();
-            var part2 = new StringBuilder();
-            for (var i = 0; i < argumentsCount; i++)
-            {
-                part1.Append($"in T{i}, ");
-                part2.Append($" T{i} arg{i},");
-            }
-            part2.Remove(part2.Length - 1, 1);
-            var name = $"Func{crtValue}";
-            return ($"public delegate TResult {name}<{part1} out TResult>({part2});", name);
+            var strTypes = string.Join(Comma, types);
+            var strNames = string.Join(Comma, names);
+            return CSharpValidatorCommon.CreateReferenceCode(strTypes, returnType, strNames, code, string.Empty, 0);
         }
 
+        internal string CreateValueCode(string[] types, string[] names, string code)
+            => CSharpValidatorCommon.CreateValueCode(types, string.Join(Comma, names), code, string.Empty, 0);
+
+        protected override (string, string) DefineDelegateCommon(int argumentsCount)
+            => CSharpValidatorCommon.DefineDelegateCommon(argumentsCount);
+
         private static object GetTypeNameFormatter()
         {
             return typeof(CSharpScript)

src/UiPath.Workflow/Microsoft/CSharp/CSharpExpressionCompiler.cs

@@ -50,8 +50,23 @@ protected override SyntaxTree GetSyntaxTreeForExpression(string expression, bool
                 .ToArray();
 
         var names = resolvedIdentifiers.Select(var => var.Name).ToArray();
-        var types = resolvedIdentifiers.Select(var => var.Type).Concat(new[] { returnType }).Select(_compilerHelper.GetTypeName).ToArray();
-        var lambdaFuncCode = _compilerHelper.CreateExpressionCode(types, names, expression);
-        return CSharpSyntaxTree.ParseText(lambdaFuncCode, _compilerHelper.ScriptParseOptions);
+        var types = resolvedIdentifiers.Select(var => var.Type).Select(_compilerHelper.GetTypeName).ToArray();
+        string expressionCode;
+        if (isLocation)
+        {
+            expressionCode = _compilerHelper.CreateReferenceCode(types: types,
+                returnType: _compilerHelper.GetTypeName(returnType),
+                names: names,
+                code: expression);
+        }
+        else
+        {
+            types = types.Concat(new[] { _compilerHelper.GetTypeName(returnType) }).ToArray();
+            expressionCode = _compilerHelper.CreateValueCode(types: types,
+                names: names,
+                code: expression);
+        }
+
+        return CSharpSyntaxTree.ParseText(expressionCode, _compilerHelper.ScriptParseOptions);
     }
 }

src/UiPath.Workflow/Utils/CSharpValidatorCommon.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+namespace System.Activities;
+
+internal static class CSharpValidatorCommon
+{
+    private static int crt = 0;
+
+    // This is used in case the expression does not properly close (e.g. missing quotes, or multiline comment not closed)
+    private const string _expressionEnder = "// */ // \"";
+
+    private const string _valueValidationTemplate = "public static System.Linq.Expressions.Expression<System.Func<{0}>> CreateExpression{1}()//activityId:{4}\n => ({2}) => {3}; {5}";
+    private const string _delegateValueValidationTemplate = "{0}\npublic static System.Linq.Expressions.Expression<{1}<{2}>> CreateExpression{3}()//activityId:{6}\n => ({4}) => {5}; {7}";
+    private const string _referenceValidationTemplate = "public static {0} IsLocation{1}()//activityId:{5}\n => ({2}) => {3} = default({4}); {6}";
+
+    internal static string CreateReferenceCode(string types, string returnType, string names, string code, string activityId, int index)
+    {
+        var actionDefinition = !string.IsNullOrWhiteSpace(types)
+            ? $"System.Action<{string.Join(CompilerHelper.Comma, types)}>"
+            : "System.Action";
+        return string.Format(_referenceValidationTemplate, actionDefinition, index, names, code, returnType, activityId, _expressionEnder);
+    }
+
+    internal static string CreateValueCode(IEnumerable<string> types, string names, string code, string activityId, int index)
+    {
+        var serializedArgumentTypes = string.Join(CompilerHelper.Comma, types);
+        if (types.Count() <= 16) // .net defines Func<TResult>...Func<T1,...T16,TResult)
+            return string.Format(_valueValidationTemplate, serializedArgumentTypes, index, names, code, activityId, _expressionEnder);
+
+        var (myDelegate, name) = DefineDelegateCommon(types.Count() - 1);
+        return string.Format(_delegateValueValidationTemplate, myDelegate, name, serializedArgumentTypes, index, names, code, activityId, _expressionEnder);
+    }
+
+    internal static (string, string) DefineDelegateCommon(int argumentsCount)
+    {
+        var crtValue = Interlocked.Add(ref crt, 1);
+
+        var part1 = new StringBuilder();
+        var part2 = new StringBuilder();
+        for (var i = 0; i < argumentsCount; i++)
+        {
+            part1.Append($"in T{i}, ");
+            part2.Append($" T{i} arg{i},");
+        }
+        part2.Remove(part2.Length - 1, 1);
+        var name = $"Func{crtValue}";
+        return ($"public delegate TResult {name}<{part1} out TResult>({part2});", name);
+    }
+}

src/UiPath.Workflow/Validation/CSharpExpressionValidator.cs

@@ -18,13 +18,6 @@ namespace System.Activities.Validation;
 /// </summary>
 public class CSharpExpressionValidator : RoslynExpressionValidator
 {
-    // This is used in case the expression does not properly close (e.g. missing quotes, or multiline comment not closed)
-    private const string _expressionEnder = "// */ // \"";
-
-    private const string _valueValidationTemplate = "public static System.Linq.Expressions.Expression<System.Func<{0}>> CreateExpression{1}()//activityId:{4}\n => ({2}) => {3}; {5}";
-    private const string _delegateValueValidationTemplate = "{0}\npublic static System.Linq.Expressions.Expression<{1}<{2}>> CreateExpression{3}()//activityId:{6}\n => ({4}) => {5}; {7}";
-    private const string _referenceValidationTemplate = "public static {0} IsLocation{1}()//activityId:{5}\n => ({2}) => {3} = default({4}); {6}";
-
     private static readonly Lazy<CSharpExpressionValidator> s_instance = new(() => new());
     public override string Language => CSharpHelper.Language;
 
@@ -66,22 +59,10 @@ protected override Compilation GetCompilation(IReadOnlyCollection<Assembly> asse
     }
 
     protected override string CreateValueCode(IEnumerable<string> types, string names, string code, string activityId, int index)
-    {
-        var serializedArgumentTypes = string.Join(Comma, types);
-        if (types.Count() <= 16) // .net defines Func<TResult>...Funct<T1,...T16,TResult)
-            return string.Format(_valueValidationTemplate, serializedArgumentTypes, index, names, code, activityId, _expressionEnder);
-
-        var (myDelegate, name) = CompilerHelper.DefineDelegate(types);
-        return string.Format(_delegateValueValidationTemplate, myDelegate, name, serializedArgumentTypes, index, names, code, activityId, _expressionEnder);
-    }
+        => CSharpValidatorCommon.CreateValueCode(types, names, code, activityId, index);
 
     protected override string CreateReferenceCode(string types, string names, string code, string activityId, string returnType, int index)
-    {
-        var actionDefinition = !string.IsNullOrWhiteSpace(types)
-            ? $"System.Action<{string.Join(Comma, types)}>"
-            : "System.Action";
-        return string.Format(_referenceValidationTemplate, actionDefinition, index, names, code, returnType, activityId, _expressionEnder);
-    }
+        => CSharpValidatorCommon.CreateReferenceCode(types, returnType, names, code, activityId, index);
 
     protected override SyntaxTree GetSyntaxTreeForExpression(string expressionText) =>
         CSharpSyntaxTree.ParseText(expressionText, CompilerHelper.ScriptParseOptions);

src/UiPath.Workflow/XamlIntegration/TextExpressionCompiler.cs

@@ -1525,7 +1525,8 @@ private void GenerateExpressionGetTreeMethod(Activity activity, CompiledExpressi
         }
         else if (IsCs)
         {
-            expressionText = string.Concat(CSharpLambdaString, coreExpressionText);
+            var safeCastText = SafeCastText(coreExpressionText, expressionDescriptor.ResultType);
+            expressionText = string.Concat(CSharpLambdaString, safeCastText);
         }
 
         if (expressionText != null)
@@ -1570,7 +1571,16 @@ private CodeMemberMethod GenerateGetMethod(Activity activity, Type resultType, s
             new CodeAttributeDeclaration(new CodeTypeReference(typeof(DebuggerHiddenAttribute))));
 
         AlignText(activity, ref expressionText, out var pragma);
-        CodeStatement statement = new CodeMethodReturnStatement(new CodeSnippetExpression(expressionText));
+        CodeStatement statement;
+        if (IsCs)
+        {
+            statement = new CodeMethodReturnStatement(SafeCast(expressionText, resultType));
+        }
+        else
+        {
+            statement = new CodeMethodReturnStatement(new CodeSnippetExpression(expressionText));
+        }
+        
         statement.LinePragma = pragma;
         expressionMethod.Statements.Add(statement);
 
@@ -2512,6 +2522,55 @@ private string GetActivityFullName(TextExpressionCompilerSettings settings)
         return activityFullName;
     }
 
+    /// <summary>
+    /// Creates a CodeSnippetExpression like: "variableName as TargetType".
+    /// If variableName or targetType is null/empty, falls back to "null".
+    /// </summary>
+    private CodeSnippetExpression SafeCast(string variableName, Type targetType)
+        => new CodeSnippetExpression(SafeCastText(variableName, targetType));
+
+    /// <summary>
+    /// Safely formats a string representation of a variable name and its target type.
+    /// Validates that the 'as' operator is only applied to reference types or nullable value types.
+    /// For non-nullable value types, returns the variable name without any casting.
+    /// </summary>
+    /// <param name="variableName">The name of the variable to be cast. If null or whitespace, "null" is used instead.</param>
+    /// <param name="targetType">The target <see cref="Type"/> to which the variable is being cast.</param>
+    /// <returns>A string in the format "<paramref name="variableName"/> as <paramref name="targetType"/>" for valid types, otherwise just the variable name.</returns>
+    private string SafeCastText(string variableName, Type targetType)
+    {
+        string varName = string.IsNullOrWhiteSpace(variableName) ? "null" : variableName;
+        
+        // Early exit if targetType is null or if it's a non-nullable value type
+        if (targetType == null || (targetType.IsValueType && !IsNullableValueType(targetType)))
+        {
+            return varName;
+        }
+
+        string typeName = GetFriendlyTypeName(targetType);
+        if (typeName == null)
+        {
+            return varName;
+        }
+
+        // Use 'as' operator for reference types and nullable value types
+        return $"{varName} as {typeName}";
+    }
+
+    private string GetFriendlyTypeName(Type type)
+    {
+        using var codeDomProvider = CodeDomProvider.CreateProvider(_settings.Language);
+        return type is null ? null : codeDomProvider.GetTypeOutput(new CodeTypeReference(type));
+    }
+
+    /// <summary>
+    /// Helper method to check if a type is a nullable value type (e.g., int?, DateTime?)
+    /// </summary>
+    private static bool IsNullableValueType(Type type)
+    {
+        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
+    }
+
     private class ExpressionCompilerActivityVisitor : CompiledExpressionActivityVisitor
     {
         private readonly TextExpressionCompiler _compiler;