Support string to enum conversion using "in-expression"

Author: StefH

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

@@ -365,78 +365,26 @@ private Expression ParseIn()
 
             _textParser.NextToken();
 
+            var expressions = new Dictionary<Expression, int>();
+
             if (_textParser.CurrentToken.Id == TokenId.OpenParen) // literals (or other inline list)
             {
-                var values = new List<Expression>();
-                var comparisons = new List<Expression>();
-                Expression? containsLeft = null;
-                string? containsLeftText = null;
-                var canUseContains = true;
-
                 while (_textParser.CurrentToken.Id != TokenId.CloseParen)
                 {
                     _textParser.NextToken();
 
                     // we need to parse unary expressions because otherwise 'in' clause will fail in use cases like 'in (-1, -1)' or 'in (!true)'
                     Expression right = ParseUnary();
 
-                    // if the identifier is an Enum (or nullable Enum), try to convert the right-side also to an Enum.
-                    if (TypeHelper.GetNonNullableType(left.Type).GetTypeInfo().IsEnum)
-                    {
-                        if (right is ConstantExpression constantExprRight)
-                        {
-                            right = ParseEnumToConstantExpression(token.Pos, left.Type, constantExprRight);
-                        }
-                        else if (_expressionHelper.TryUnwrapAsConstantExpression(right, out var unwrappedConstantExprRight))
-                        {
-                            right = ParseEnumToConstantExpression(token.Pos, left.Type, unwrappedConstantExprRight);
-                        }
-                    }
-
-                    // else, check for direct type match
-                    else if (left.Type != right.Type)
-                    {
-                        CheckAndPromoteOperands(typeof(IEqualitySignatures), TokenId.DoubleEqual, "==", ref left, ref right, token.Pos);
-                    }
-
-                    var equalsExpression = _expressionHelper.GenerateEqual(left, right);
-                    comparisons.Add(equalsExpression);
-
-                    if (canUseContains && equalsExpression is BinaryExpression binaryExpression && binaryExpression.NodeType == ExpressionType.Equal)
-                    {
-                        containsLeft ??= binaryExpression.Left;
-                        containsLeftText ??= binaryExpression.Left.ToString();
-
-                        if (containsLeft.Type != binaryExpression.Left.Type || !string.Equals(containsLeftText, binaryExpression.Left.ToString(), StringComparison.Ordinal) || binaryExpression.Right.Type != containsLeft.Type)
-                        {
-                            canUseContains = false;
-                        }
-                        else
-                        {
-                            values.Add(binaryExpression.Right);
-                        }
-                    }
-                    else
-                    {
-                        canUseContains = false;
-                    }
+                    expressions.Add(right, token.Pos);
 
                     if (_textParser.CurrentToken.Id == TokenId.End)
                     {
                         throw ParseError(token.Pos, Res.CloseParenOrCommaExpected);
                     }
                 }
 
-                if (canUseContains && containsLeft != null)
-                {
-                    var typeArgs = new[] { containsLeft.Type };
-                    var args = new Expression[] { Expression.NewArrayInit(containsLeft.Type, values), containsLeft };
-                    accumulate = Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), typeArgs, args);
-                }
-                else
-                {
-                    accumulate = _expressionHelper.GenerateBinaryOrElseTree(comparisons);
-                }
+                accumulate = ProcessInExpressions(accumulate, expressions);
 
                 // Since this started with an open paren, make sure to move off the close
                 _textParser.NextToken();
@@ -445,16 +393,29 @@ private Expression ParseIn()
             {
                 Expression right = ParsePrimary();
 
-                if (!typeof(IEnumerable).IsAssignableFrom(right.Type))
+                if (!TypeHelper.TryGetAsEnumerable(right.Type, out _))
                 {
-                    throw ParseError(_textParser.CurrentToken.Pos, Res.IdentifierImplementingInterfaceExpected, typeof(IEnumerable));
+                    throw ParseError(_textParser.CurrentToken.Pos, Res.IdentifierImplementingInterfaceExpected, typeof(IEnumerable<>));
                 }
 
-                var typeArgs = new[] { left.Type };
+                // Handle "it.TestEnum in @0", and the @0 should be a object like a List<string>.
+                if (_symbols.Count > 0 && right is ConstantExpression constantExprRight && constantExprRight.Value != null)
+                {
+                    foreach (var item in (IEnumerable)constantExprRight.Value)
+                    {
+                        expressions.Add(Expression.Constant(item), token.Pos);
+                    }
 
-                var args = new[] { right, left };
+                    accumulate = ProcessInExpressions(accumulate, expressions);
+                }
 
-                accumulate = Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), typeArgs, args);
+                // Handle "'y' in Name"
+                else
+                {
+                    var typeArgs = new[] { left.Type };
+                    var args = new[] { right, left };
+                    accumulate = Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), typeArgs, args);
+                }
             }
             else
             {
@@ -470,6 +431,71 @@ private Expression ParseIn()
         return accumulate;
     }
 
+    private Expression ProcessInExpressions(Expression left, Dictionary<Expression, int> expressions)
+    {
+        var values = new List<Expression>();
+        var comparisons = new List<Expression>();
+        Expression? containsLeft = null;
+        string? containsLeftText = null;
+        var canUseContains = true;
+
+        for (int i = 0; i < expressions.Count; i++)
+        {
+            var right = expressions.ElementAt(i).Key;
+            var tokenPos = expressions.ElementAt(i).Value;
+
+            // if the identifier is an Enum (or nullable Enum), try to convert the right-side also to an Enum.
+            if (TypeHelper.GetNonNullableType(left.Type).GetTypeInfo().IsEnum)
+            {
+                if (right is ConstantExpression constantExprRight)
+                {
+                    right = ParseEnumToConstantExpression(tokenPos, left.Type, constantExprRight);
+                }
+                else if (_expressionHelper.TryUnwrapAsConstantExpression(right, out var unwrappedConstantExprRight))
+                {
+                    right = ParseEnumToConstantExpression(tokenPos, left.Type, unwrappedConstantExprRight);
+                }
+            }
+
+            // else, check for direct type match
+            else if (left.Type != right.Type)
+            {
+                CheckAndPromoteOperands(typeof(IEqualitySignatures), TokenId.DoubleEqual, "==", ref left, ref right, tokenPos);
+            }
+
+            var equalsExpression = _expressionHelper.GenerateEqual(left, right);
+            comparisons.Add(equalsExpression);
+
+            if (canUseContains && equalsExpression is BinaryExpression binaryExpression && binaryExpression.NodeType == ExpressionType.Equal)
+            {
+                containsLeft ??= binaryExpression.Left;
+                containsLeftText ??= binaryExpression.Left.ToString();
+
+                if (containsLeft.Type != binaryExpression.Left.Type || !string.Equals(containsLeftText, binaryExpression.Left.ToString(), StringComparison.Ordinal) || binaryExpression.Right.Type != containsLeft.Type)
+                {
+                    canUseContains = false;
+                }
+                else
+                {
+                    values.Add(binaryExpression.Right);
+                }
+            }
+            else
+            {
+                canUseContains = false;
+            }
+        }
+
+        if (canUseContains && containsLeft != null)
+        {
+            var typeArgs = new[] { containsLeft.Type };
+            var args = new Expression[] { Expression.NewArrayInit(containsLeft.Type, values), containsLeft };
+            return Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), typeArgs, args);
+        }
+
+        return _expressionHelper.GenerateBinaryOrElseTree(comparisons);
+    }
+
     // &, | bitwise operators
     private Expression ParseLogicalAndOrOperator()
     {
@@ -2081,9 +2107,9 @@ private Expression ParseMemberAccess(Type? type, Expression? expression, string?
         throw ParseError(errorPos, Res.UnknownPropertyOrField, id, TypeHelper.GetTypeName(type));
     }
 
-    private bool TryFindPropertyOrField(Type type, string id, Expression? expression, [NotNullWhen(true)] out Expression? propertyOrFieldExpression)
+    private bool TryFindPropertyOrField(Type type, string memberName, Expression? expression, [NotNullWhen(true)] out Expression? propertyOrFieldExpression)
     {
-        var member = FindPropertyOrField(type, id, expression == null);
+        var member = FindPropertyOrField(type, memberName, expression == null);
         switch (member)
         {
             case PropertyInfo property:

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

@@ -13,20 +13,19 @@ internal static bool IsDynamicClass(Type type)
 
     internal static bool TryGetAsEnumerable(Type type, [NotNullWhen(true)] out Type? enumerableType)
     {
-        if (type.IsArray)
-        {
-            enumerableType = typeof(IEnumerable<>).MakeGenericType(type.GetElementType()!);
-            return true;
-        }
-
         if (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
         {
             enumerableType = type;
             return true;
         }
 
-        enumerableType = null;
-        return false;
+        enumerableType = type
+            .GetInterfaces()
+            .FirstOrDefault(i =>
+                i.GetTypeInfo().IsGenericType &&
+                i.GetGenericTypeDefinition() == typeof(IEnumerable<>));
+
+        return enumerableType is not null;
     }
 
     public static bool TryGetFirstGenericArgument(Type type, [NotNullWhen(true)] out Type? genericType)

test/System.Linq.Dynamic.Core.Tests/EntitiesTests.In.cs

@@ -1,7 +1,6 @@
 using System.Linq.Dynamic.Core.Tests.Helpers.Entities;
 
 #if EFCORE
-using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore;
 #else
 using System.Data.Entity;
@@ -20,10 +19,16 @@ public partial class EntitiesTests
     public void Entities_Where_In_And()
     {
         // Arrange
-        var expected = _context.Blogs.Include(b => b.Posts).Where(b => new[] { 1000, 1001, 1002 }.Contains(b.BlogId) && new[] { "Blog1", "Blog2" }.Contains(b.Name)).ToArray();
+        var expected = _context.Blogs.Include(b => b.Posts)
+            .Where(b => 
+                new[] { 1000, 1001, 1002 }.Contains(b.BlogId) && new[] { "Blog1", "Blog2" }.Contains(b.Name) && b.Name.Contains('o')
+            )
+            .ToArray();
 
         // Act
-        var test = _context.Blogs.Include(b => b.Posts).Where(@"BlogId in (1000, 1001, 1002) and Name in (""Blog1"", ""Blog2"")").ToArray();
+        var test = _context.Blogs.Include(b => b.Posts)
+            .Where(@"BlogId in (1000, 1001, 1002) and Name in (""Blog1"", ""Blog2"") && Name.Contains('o')")
+            .ToArray();
 
         // Assert
         Assert.Equal(expected, test);

test/System.Linq.Dynamic.Core.Tests/ExpressionTests.cs

@@ -1310,10 +1310,22 @@ public void ExpressionTests_In_Enum()
             var expected = qry.Where(x => new[] { TestEnum.Var1, TestEnum.Var2 }.Contains(x.TestEnum)).ToArray();
             var result1 = qry.Where("it.TestEnum in (\"Var1\", \"Var2\")").ToArray();
             var result2 = qry.Where("it.TestEnum in (0, 1)").ToArray();
+            var result3 = qry.Where("it.TestEnum in @0", new[] { TestEnum.Var1, TestEnum.Var2 });
+            var objectList = new List<string> { "Var1", "Var2" };
+            var result4 = qry.Where("it.TestEnum in @0", objectList);
+            var result5 = qry.Where("it.TestEnum in @0", GetVar1AndVar2());
 
             // Assert
-            Check.That(result1).ContainsExactly(expected);
-            Check.That(result2).ContainsExactly(expected);
+            Assert.Equivalent(result1, expected);
+            Assert.Equivalent(result2, expected);
+            Assert.Equivalent(result3, expected);
+            Assert.Equivalent(result4, expected);
+            Assert.Equivalent(result5, expected);
+        }
+
+        private static List<string> GetVar1AndVar2()
+        {
+            return new List<string> { "Var1", "Var" + "2" };
         }
 
         [Fact]
@@ -1330,10 +1342,18 @@ public void ExpressionTests_In_EnumIsNullable()
             var expected = new[] { model1, model2 };
             var result1 = qry.Where("it.TestEnumNullable in (\"Var1\", \"Var2\")").ToArray();
             var result2 = qry.Where("it.TestEnumNullable in (0, 1)").ToArray();
+            var result3 = qry.Where("it.TestEnumNullable in @0", new[] { TestEnum.Var1, TestEnum.Var2 });
+
+            var objectList = new List<string> { "Var1", "Var2" };
+            var result4 = qry.Where("it.TestEnumNullable in @0", objectList);
+            var result5 = qry.Where("it.TestEnumNullable in @0", GetVar1AndVar2());
 
             // Assert
-            Check.That(result1).ContainsExactly(expected);
-            Check.That(result2).ContainsExactly(expected);
+            Assert.Equivalent(result1, expected);
+            Assert.Equivalent(result2, expected);
+            Assert.Equivalent(result3, expected);
+            Assert.Equivalent(result4, expected);
+            Assert.Equivalent(result5, expected);
         }
 
         [Fact]

test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.cs

@@ -266,13 +266,14 @@ public void Parse_ParseMultipleInOperators()
     {
         // Arrange
         ParameterExpression[] parameters = [ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "x")];
-        var sut = new ExpressionParser(parameters, "MainCompanyId in (1, 2) and Name in (\"A\", \"B\") && 'y' in Name && 'z' in Name", null, null);
+        var values = new object?[] { new List<int> { 42, 43 }, new List<int> { 100, 100 + 1 } };
+        var sut = new ExpressionParser(parameters, "MainCompanyId in (1, 2) and Name in (\"A\", \"B\") && 'y' in Name && 'z' in Name and MainCompanyId in @0 and MainCompanyId in @1", values, null);
 
         // Act
         var parsedExpression = sut.Parse(null).ToString();
 
         // Assert
-        Check.That(parsedExpression).Equals("(((new [] {1, 2}.Contains(x.MainCompanyId) AndAlso new [] {\"A\", \"B\"}.Contains(x.Name)) AndAlso x.Name.Contains(y)) AndAlso x.Name.Contains(z))");
+        Check.That(parsedExpression).Equals("(((((new [] {1, 2}.Contains(x.MainCompanyId) AndAlso new [] {\"A\", \"B\"}.Contains(x.Name)) AndAlso x.Name.Contains(y)) AndAlso x.Name.Contains(z)) AndAlso new [] {42, 43}.Contains(x.MainCompanyId)) AndAlso new [] {100, 101}.Contains(x.MainCompanyId))");
     }
 
     [Fact]
@@ -326,13 +327,13 @@ public void Parse_ParseInWrappedInParenthesis()
     {
         // Arrange
         ParameterExpression[] parameters = [ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "x")];
-        var sut = new ExpressionParser(parameters, "(MainCompanyId in @0)", [new long?[] { 1, 2 }], null);
+        var sut = new ExpressionParser(parameters, "(MainCompanyId in @0)", [new long?[] { 1, (long) int.MaxValue + 1 }], null);
 
         // Act
         var parsedExpression = sut.Parse(null).ToString();
 
         // Assert
-        Check.That(parsedExpression).Equals("value(System.Nullable`1[System.Int64][]).Contains(x.MainCompanyId)");
+        Check.That(parsedExpression).Equals("new [] {1, 2147483648}.Contains(x.MainCompanyId)");
     }
 
     [Fact]