Add support for casting a string to another type (e.g. int) for Linq2Objects (#686)

* .

* .

* c

* .

* tst

Author: StefH

src/System.Linq.Dynamic.Core/Parser/ExpressionHelper.cs

@@ -176,8 +176,10 @@ public Expression GenerateGreaterThanEqual(Expression left, Expression right)
 
         if (left.Type.GetTypeInfo().IsEnum || right.Type.GetTypeInfo().IsEnum)
         {
-            return Expression.GreaterThanOrEqual(left.Type.GetTypeInfo().IsEnum ? Expression.Convert(left, Enum.GetUnderlyingType(left.Type)) : left,
-                right.Type.GetTypeInfo().IsEnum ? Expression.Convert(right, Enum.GetUnderlyingType(right.Type)) : right);
+            return Expression.GreaterThanOrEqual(
+                left.Type.GetTypeInfo().IsEnum ? Expression.Convert(left, Enum.GetUnderlyingType(left.Type)) : left,
+                right.Type.GetTypeInfo().IsEnum ? Expression.Convert(right, Enum.GetUnderlyingType(right.Type)) : right
+            );
         }
 
         WrapConstantExpressions(ref left, ref right);
@@ -194,8 +196,10 @@ public Expression GenerateLessThan(Expression left, Expression right)
 
         if (left.Type.GetTypeInfo().IsEnum || right.Type.GetTypeInfo().IsEnum)
         {
-            return Expression.LessThan(left.Type.GetTypeInfo().IsEnum ? Expression.Convert(left, Enum.GetUnderlyingType(left.Type)) : left,
-                right.Type.GetTypeInfo().IsEnum ? Expression.Convert(right, Enum.GetUnderlyingType(right.Type)) : right);
+            return Expression.LessThan(
+                left.Type.GetTypeInfo().IsEnum ? Expression.Convert(left, Enum.GetUnderlyingType(left.Type)) : left,
+                right.Type.GetTypeInfo().IsEnum ? Expression.Convert(right, Enum.GetUnderlyingType(right.Type)) : right
+            );
         }
 
         WrapConstantExpressions(ref left, ref right);
@@ -212,8 +216,10 @@ public Expression GenerateLessThanEqual(Expression left, Expression right)
 
         if (left.Type.GetTypeInfo().IsEnum || right.Type.GetTypeInfo().IsEnum)
         {
-            return Expression.LessThanOrEqual(left.Type.GetTypeInfo().IsEnum ? Expression.Convert(left, Enum.GetUnderlyingType(left.Type)) : left,
-                right.Type.GetTypeInfo().IsEnum ? Expression.Convert(right, Enum.GetUnderlyingType(right.Type)) : right);
+            return Expression.LessThanOrEqual(
+                left.Type.GetTypeInfo().IsEnum ? Expression.Convert(left, Enum.GetUnderlyingType(left.Type)) : left,
+                right.Type.GetTypeInfo().IsEnum ? Expression.Convert(right, Enum.GetUnderlyingType(right.Type)) : right
+            );
         }
 
         WrapConstantExpressions(ref left, ref right);
@@ -264,22 +270,22 @@ public void OptimizeForEqualityIfPossible(ref Expression left, ref Expression ri
             return Expression.Constant(guid, typeof(Guid));
         }
 #else
-            try
-            {
-                return Expression.Constant(new Guid(text));
-            }
-            catch
-            {
-                // Doing it in old fashion way when no TryParse interface was provided by .NET
-            }
+        try
+        {
+            return Expression.Constant(new Guid(text));
+        }
+        catch
+        {
+            // Doing it in old fashion way when no TryParse interface was provided by .NET
+        }
 #endif
         return null;
     }
 
     public bool MemberExpressionIsDynamic(Expression expression)
     {
 #if NET35
-            return false;
+        return false;
 #else
         return expression is MemberExpression memberExpression && memberExpression.Member.GetCustomAttribute<DynamicAttribute>() != null;
 #endif
@@ -290,21 +296,10 @@ public Expression ConvertToExpandoObjectAndCreateDynamicExpression(Expression ex
 #if !NET35 && !UAP10_0 && !NETSTANDARD1_3
         return Expression.Dynamic(new DynamicGetMemberBinder(propertyName, _parsingConfig), type, expression);
 #else
-            throw new NotSupportedException(Res.DynamicExpandoObjectIsNotSupported);
+        throw new NotSupportedException(Res.DynamicExpandoObjectIsNotSupported);
 #endif
     }
 
-    private MethodInfo GetStaticMethod(string methodName, Expression left, Expression right)
-    {
-        var methodInfo = left.Type.GetMethod(methodName, new[] { left.Type, right.Type });
-        if (methodInfo == null)
-        {
-            methodInfo = right.Type.GetMethod(methodName, new[] { left.Type, right.Type })!;
-        }
-
-        return methodInfo;
-    }
-
     private Expression GenerateStaticMethodCall(string methodName, Expression left, Expression right)
     {
         return Expression.Call(null, GetStaticMethod(methodName, left, right), new[] { left, right });
@@ -350,17 +345,13 @@ public bool TryGenerateAndAlsoNotNullExpression(Expression sourceExpression, boo
 
     public bool ExpressionQualifiesForNullPropagation(Expression? expression)
     {
-        return
-            expression is MemberExpression ||
-            expression is ParameterExpression ||
-            expression is MethodCallExpression ||
-            expression is UnaryExpression;
+        return expression is MemberExpression or ParameterExpression or MethodCallExpression or UnaryExpression;
     }
 
     public Expression GenerateDefaultExpression(Type type)
     {
 #if NET35
-            return Expression.Constant(Activator.CreateInstance(type));
+        return Expression.Constant(Activator.CreateInstance(type));
 #else
         return Expression.Default(type);
 #endif
@@ -391,7 +382,7 @@ public Expression GenerateDefaultExpression(Type type)
 
     private List<Expression> CollectExpressions(bool addSelf, Expression sourceExpression)
     {
-        Expression? expression = GetMemberExpression(sourceExpression);
+        var expression = GetMemberExpression(sourceExpression);
 
         var list = new List<Expression>();
 
@@ -443,6 +434,17 @@ private List<Expression> CollectExpressions(bool addSelf, Expression sourceExpre
         return list;
     }
 
+    private static MethodInfo GetStaticMethod(string methodName, Expression left, Expression right)
+    {
+        var methodInfo = left.Type.GetMethod(methodName, new[] { left.Type, right.Type });
+        if (methodInfo == null)
+        {
+            methodInfo = right.Type.GetMethod(methodName, new[] { left.Type, right.Type })!;
+        }
+
+        return methodInfo;
+    }
+
     private static Expression? GetMethodCallExpression(MethodCallExpression methodCallExpression)
     {
         if (methodCallExpression.Object != null)

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -1,6 +1,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq.Dynamic.Core.Exceptions;
 using System.Linq.Dynamic.Core.Parser.SupportedMethods;
@@ -19,10 +20,10 @@ namespace System.Linq.Dynamic.Core.Parser;
 /// </summary>
 public class ExpressionParser
 {
-    private static readonly string methodOrderBy = nameof(Queryable.OrderBy);
-    private static readonly string methodOrderByDescending = nameof(Queryable.OrderByDescending);
-    private static readonly string methodThenBy = nameof(Queryable.ThenBy);
-    private static readonly string methodThenByDescending = nameof(Queryable.ThenByDescending);
+    private const string MethodOrderBy = nameof(Queryable.OrderBy);
+    private const string MethodOrderByDescending = nameof(Queryable.OrderByDescending);
+    private const string MethodThenBy = nameof(Queryable.ThenBy);
+    private const string MethodThenByDescending = nameof(Queryable.ThenByDescending);
 
     private readonly ParsingConfig _parsingConfig;
     private readonly MethodFinder _methodFinder;
@@ -51,7 +52,7 @@ public class ExpressionParser
     /// There was a problem when an expression contained multiple lambdas where
     /// the ItName was not cleared and freed for the next lambda. This variable
     /// stores the ItName of the last parsed lambda.
-    /// Not used internally by ExpressionParser, but used to preserve compatiblity of parsingConfig.RenameParameterExpression
+    /// Not used internally by ExpressionParser, but used to preserve compatibility of parsingConfig.RenameParameterExpression
     /// which was designed to only work with mono-lambda expressions.
     /// </summary>
     public string LastLambdaItName { get; private set; } = KeywordsHelper.KEYWORD_IT;
@@ -93,7 +94,7 @@ private void ProcessParameters(ParameterExpression[] parameters)
     {
         foreach (ParameterExpression pe in parameters.Where(p => !string.IsNullOrEmpty(p.Name)))
         {
-            AddSymbol(pe.Name, pe);
+            AddSymbol(pe.Name!, pe);
         }
 
         // If there is only 1 ParameterExpression, do also allow access using 'it'
@@ -185,11 +186,11 @@ internal IList<DynamicOrdering> ParseOrdering(bool forceThenBy = false)
             string methodName;
             if (forceThenBy || orderings.Count > 0)
             {
-                methodName = ascending ? methodThenBy : methodThenByDescending;
+                methodName = ascending ? MethodThenBy : MethodThenByDescending;
             }
             else
             {
-                methodName = ascending ? methodOrderBy : methodOrderByDescending;
+                methodName = ascending ? MethodOrderBy : MethodOrderByDescending;
             }
 
             orderings.Add(new DynamicOrdering { Selector = expr, Ascending = ascending, MethodName = methodName });
@@ -404,11 +405,11 @@ private Expression ParseLogicalAndOrOperator()
             switch (op.Id)
             {
                 case TokenId.Ampersand:
-                    if (left.Type == typeof(string) && left.NodeType == ExpressionType.Constant && int.TryParse((string)((ConstantExpression)left).Value, out var parseValue) && TypeHelper.IsNumericType(right.Type))
+                    if (left.Type == typeof(string) && left.NodeType == ExpressionType.Constant && int.TryParse((string?)((ConstantExpression)left).Value, out var parseValue) && TypeHelper.IsNumericType(right.Type))
                     {
                         left = Expression.Constant(parseValue);
                     }
-                    else if (right.Type == typeof(string) && right.NodeType == ExpressionType.Constant && int.TryParse((string)((ConstantExpression)right).Value, out parseValue) && TypeHelper.IsNumericType(left.Type))
+                    else if (right.Type == typeof(string) && right.NodeType == ExpressionType.Constant && int.TryParse((string?)((ConstantExpression)right).Value, out parseValue) && TypeHelper.IsNumericType(left.Type))
                     {
                         right = Expression.Constant(parseValue);
                     }
@@ -1172,7 +1173,14 @@ private Expression ParseFunctionCast()
             it = args[0];
         }
 
-        return Expression.ConvertChecked(it, ResolveTypeFromArgumentExpression(functionName, typeArgument, args.Length));
+        var destinationType = ResolveTypeFromArgumentExpression(functionName, typeArgument, args.Length);
+
+        if (TryGenerateConversion(it, destinationType, out var conversionExpression))
+        {
+            return conversionExpression;
+        }
+
+        return Expression.ConvertChecked(it, destinationType);
     }
 
     private Expression GenerateConditional(Expression test, Expression expressionIfTrue, Expression expressionIfFalse, bool nullPropagating, int errorPos)
@@ -1360,9 +1368,9 @@ private Expression ParseNew()
                             && methodCallExpression.Arguments.Count == 1
                             && methodCallExpression.Arguments[0] is ConstantExpression methodCallExpressionArgument
                             && methodCallExpressionArgument.Type == typeof(string)
-                            && properties.All(x => x.Name != (string)methodCallExpressionArgument.Value))
+                            && properties.All(x => x.Name != (string?)methodCallExpressionArgument.Value))
                         {
-                            propName = (string)methodCallExpressionArgument.Value;
+                            propName = (string?)methodCallExpressionArgument.Value;
                         }
                         else
                         {
@@ -1442,7 +1450,7 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
             // Create an expression tree that represents creating and initializing a one-dimensional array of type KeyValuePair<string, object>.
             NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(KeyValuePair<string, object>), arrayIndexParams);
 
-            // Get the "public DynamicClass(KeyValuePair<string, object>[] propertylist)" constructor
+            // Get the "public DynamicClass(KeyValuePair<string, object>[])" constructor
             ConstructorInfo constructor = type.GetTypeInfo().DeclaredConstructors.First();
 
             return Expression.New(constructor, newArrayExpression);
@@ -1621,7 +1629,7 @@ private Expression ParseTypeAccess(Type type, bool getNext)
                 case 0:
                     if (args.Length == 1 && TryGenerateConversion(args[0], type, out generatedExpression))
                     {
-                        return generatedExpression!;
+                        return generatedExpression;
                     }
 
                     throw ParseError(errorPos, Res.NoMatchingConstructor, TypeHelper.GetTypeName(type));
@@ -1640,56 +1648,61 @@ private Expression ParseTypeAccess(Type type, bool getNext)
         return ParseMemberAccess(type, null);
     }
 
-    private bool TryGenerateConversion(Expression sourceExpression, Type type, out Expression? expression)
+    private bool TryGenerateConversion(Expression sourceExpression, Type destinationType, [NotNullWhen(true) ]out Expression? expression)
     {
         Type exprType = sourceExpression.Type;
-        if (exprType == type)
+        if (exprType == destinationType)
         {
             expression = sourceExpression;
             return true;
         }
 
-        if (exprType.GetTypeInfo().IsValueType && type.GetTypeInfo().IsValueType)
+        if (exprType.GetTypeInfo().IsValueType && destinationType.GetTypeInfo().IsValueType)
         {
-            if ((TypeHelper.IsNullableType(exprType) || TypeHelper.IsNullableType(type)) && TypeHelper.GetNonNullableType(exprType) == TypeHelper.GetNonNullableType(type))
+            if ((TypeHelper.IsNullableType(exprType) || TypeHelper.IsNullableType(destinationType)) && TypeHelper.GetNonNullableType(exprType) == TypeHelper.GetNonNullableType(destinationType))
             {
-                expression = Expression.Convert(sourceExpression, type);
+                expression = Expression.Convert(sourceExpression, destinationType);
                 return true;
             }
 
-            if ((TypeHelper.IsNumericType(exprType) || TypeHelper.IsEnumType(exprType)) && TypeHelper.IsNumericType(type) || TypeHelper.IsEnumType(type))
+            if ((TypeHelper.IsNumericType(exprType) || TypeHelper.IsEnumType(exprType)) && TypeHelper.IsNumericType(destinationType) || TypeHelper.IsEnumType(destinationType))
             {
-                expression = Expression.ConvertChecked(sourceExpression, type);
+                expression = Expression.ConvertChecked(sourceExpression, destinationType);
                 return true;
             }
         }
 
-        if (exprType.IsAssignableFrom(type) || type.IsAssignableFrom(exprType) || exprType.GetTypeInfo().IsInterface || type.GetTypeInfo().IsInterface)
+        if (exprType.IsAssignableFrom(destinationType) || destinationType.IsAssignableFrom(exprType) || exprType.GetTypeInfo().IsInterface || destinationType.GetTypeInfo().IsInterface)
         {
-            expression = Expression.Convert(sourceExpression, type);
+            expression = Expression.Convert(sourceExpression, destinationType);
             return true;
         }
 
         // Try to Parse the string rather than just generate the convert statement
-        if (sourceExpression.NodeType == ExpressionType.Constant && exprType == typeof(string))
+        if (sourceExpression is ConstantExpression { Value: string constantStringValue })
         {
-            string text = (string)((ConstantExpression)sourceExpression).Value;
-
-            var typeConvertor = _typeConverterFactory.GetConverter(type);
-            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
-            if (typeConvertor != null && typeConvertor.CanConvertFrom(typeof(string)))
+            var typeConvertor = _typeConverterFactory.GetConverter(destinationType);
+            if (typeConvertor.CanConvertFrom(typeof(string)))
             {
-                var value = typeConvertor.ConvertFromInvariantString(text);
-                expression = Expression.Constant(value, type);
+                var value = typeConvertor.ConvertFromInvariantString(constantStringValue);
+                expression = Expression.Constant(value, destinationType);
                 return true;
             }
         }
 
         // Check if there are any explicit conversion operators on the source type which fit the requirement (cast to the return type).
-        bool explicitOperatorAvailable = exprType.GetTypeInfo().GetDeclaredMethods("op_Explicit").Any(m => m.ReturnType == type);
+        bool explicitOperatorAvailable = exprType.GetTypeInfo().GetDeclaredMethods("op_Explicit").Any(m => m.ReturnType == destinationType);
         if (explicitOperatorAvailable)
         {
-            expression = Expression.Convert(sourceExpression, type);
+            expression = Expression.Convert(sourceExpression, destinationType);
+            return true;
+        }
+
+        // Try to find a destinationType.Parse(...) method for the specific sourceExpression Type.
+        var parseMethod = destinationType.GetMethod("Parse", new Type[] { sourceExpression.Type });
+        if (parseMethod != null)
+        {
+            expression = Expression.Call(parseMethod, sourceExpression);
             return true;
         }
 
@@ -1788,7 +1801,7 @@ private Expression ParseMemberAccess(Type? type, Expression? expression)
         if (type == typeof(object))
         {
             // The member is a dynamic or ExpandoObject, so convert this
-            return _expressionHelper.ConvertToExpandoObjectAndCreateDynamicExpression(expression, type, id);
+            return _expressionHelper.ConvertToExpandoObjectAndCreateDynamicExpression(expression!, type, id);
         }
 #endif
         // Parse as Lambda
@@ -1798,7 +1811,7 @@ private Expression ParseMemberAccess(Type? type, Expression? expression)
         }
 
         // This could be enum like "A.B.C.MyEnum.Value1" or "A.B.C+MyEnum.Value1"
-        if (_textParser.CurrentToken.Id == TokenId.Dot || _textParser.CurrentToken.Id == TokenId.Plus)
+        if (_textParser.CurrentToken.Id is TokenId.Dot or TokenId.Plus)
         {
             return ParseAsEnum(id);
         }

src/System.Linq.Dynamic.Core/TypeConverters/TypeConverterFactory.cs

@@ -38,8 +38,7 @@ public TypeConverter GetConverter(Type type)
         }
 
 #if !SILVERLIGHT
-        var c = TypeDescriptor.GetConverter(type);
-        return c;
+        return TypeDescriptor.GetConverter(type);
 #else
         var attributes = type.GetCustomAttributes(typeof(TypeConverterAttribute), false);
 
@@ -52,7 +51,7 @@ public TypeConverter GetConverter(Type type)
         if (converterType == null)
             return new TypeConverter();
 
-        return Activator.CreateInstance(converterType) as TypeConverter;
+        return (TypeConverter) Activator.CreateInstance(converterType);
 #endif
     }
 }

src/System.Linq.Dynamic.Core/Util/ParameterExpressionRenamer.cs

@@ -29,11 +29,8 @@ public ParameterExpressionRenamer(string newName) : this(string.Empty, newName)
     /// <param name="newName">The new name.</param>
     public ParameterExpressionRenamer(string oldName, string newName)
     {
-        Check.NotNull(oldName);
-        Check.NotEmpty(newName);
-
-        _oldName = oldName;
-        _newName = newName;
+        _oldName = Check.NotNull(oldName);
+        _newName = Check.NotEmpty(newName);
     }
 
     /// <summary>
@@ -67,4 +64,4 @@ protected override Expression VisitParameter(ParameterExpression node)
 
         return node;
     }
-}
+}