Fix when using LINQ methods like "Any" on a string (#798)

* ?

* t

* #440

Author: StefH

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

@@ -1795,19 +1795,25 @@ private Expression ParseMemberAccess(Type? type, Expression? expression, string?
 
         if (_textParser.CurrentToken.Id == TokenId.OpenParen)
         {
+            Expression[]? args = null;
+
             var isStaticAccess = expression == null;
 
-            if (!isStaticAccess && type != typeof(string))
+            if (!isStaticAccess)
             {
                 var enumerableType = TypeHelper.FindGenericType(typeof(IEnumerable<>), type);
                 if (enumerableType != null)
                 {
-                    Type elementType = enumerableType.GetTypeInfo().GetGenericTypeArguments()[0];
-                    return ParseEnumerable(expression!, elementType, id, errorPos, type);
+                    var elementType = enumerableType.GetTypeInfo().GetGenericTypeArguments()[0];
+                    if (TryParseEnumerable(expression!, elementType, id, errorPos, type, out args, out var enumerableExpression))
+                    {
+                        return enumerableExpression;
+                    }
                 }
             }
 
-            Expression[] args = ParseArgumentList();
+            // If args is not set by TryParseEnumerable (in case when the expression is not an Enumerable), do parse the argument list here.
+            args ??= ParseArgumentList();
             switch (_methodFinder.FindMethod(type, id, isStaticAccess, ref expression, ref args, out var methodBase))
             {
                 case 0:
@@ -2038,7 +2044,7 @@ private Expression ParseAsEnumOrNestedClass(string id)
         return ParseMemberAccess(type, null, identifier);
     }
 
-    private Expression ParseEnumerable(Expression instance, Type elementType, string methodName, int errorPos, Type? type)
+    private bool TryParseEnumerable(Expression instance, Type elementType, string methodName, int errorPos, Type? type, out Expression[]? args, [NotNullWhen(true)] out Expression? expression)
     {
         var oldParent = _parent;
 
@@ -2057,15 +2063,24 @@ private Expression ParseEnumerable(Expression instance, Type elementType, string
             _it = innerIt;
         }
 
-        Expression[] args = ParseArgumentList();
+        args = ParseArgumentList();
+
+        var t = type ?? instance.Type;
+        if (t == typeof(string) && _methodFinder.ContainsMethod(t, methodName, false, instance, ref args))
+        {
+            // In case the type is a string, and does contain the methodName (like "IndexOf"), then return false to indicate that the methodName is not an Enumerable method.
+            expression = null;
+            return false;
+        }
 
         _it = outerIt;
         _parent = oldParent;
 
         if (type != null && TypeHelper.IsDictionary(type) && _methodFinder.ContainsMethod(type, methodName, false))
         {
             var dictionaryMethod = type.GetMethod(methodName)!;
-            return Expression.Call(instance, dictionaryMethod, args);
+            expression = Expression.Call(instance, dictionaryMethod, args);
+            return true;
         }
 
         // #794 - Check if the method is an aggregate (Average or Sum) method and try to update the arguments to match the method arguments
@@ -2139,7 +2154,8 @@ private Expression ParseEnumerable(Expression instance, Type elementType, string
             }
         }
 
-        return Expression.Call(callType, methodName, typeArgs, args);
+        expression = Expression.Call(callType, methodName, typeArgs, args);
+        return true;
     }
 
     private Type ResolveTypeFromArgumentExpression(string functionName, Expression argumentExpression, int? arguments = null)

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

@@ -2088,15 +2088,25 @@ public void ExpressionTests_StringEscaping()
             var baseQuery = new[] { new { Value = "ab\"cd" }, new { Value = "a \\ b" } }.AsQueryable();
 
             // Act
-            var result1 = baseQuery.Where("it.Value == \"ab\\\"cd\"").ToList();
-            var result2 = baseQuery.Where("it.Value.IndexOf('\\\\') != -1").ToList();
-
+            var result = baseQuery.Where("it.Value == \"ab\\\"cd\"").ToList();
+            
             // Assert
-            Assert.Single(result1);
-            Assert.Equal("ab\"cd", result1[0].Value);
+            Assert.Single(result);
+            Assert.Equal("ab\"cd", result[0].Value);
+        }
+
+        [Fact]
+        public void ExpressionTests_StringIndexOf()
+        {
+            // Arrange
+            var baseQuery = new[] { new { Value = "ab\"cd" }, new { Value = "a \\ b" } }.AsQueryable();
 
-            Assert.Single(result2);
-            Assert.Equal("a \\ b", result2[0].Value);
+            // Act
+            var result = baseQuery.Where("it.Value.IndexOf('\\\\') != -1").ToList();
+
+            // Assert
+            Assert.Single(result);
+            Assert.Equal("a \\ b", result[0].Value);
         }
 
         [Fact]

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

@@ -284,6 +284,20 @@ public void Parse_ParseInWrappedInParenthesis()
         Check.That(parsedExpression).Equals("value(System.Nullable`1[System.Int64][]).Contains(x.MainCompanyId)");
     }
 
+    [Fact]
+    public void Parse_CastActingOnIt()
+    {
+        // Arrange
+        var parameters = new[] { ParameterExpressionHelper.CreateParameterExpression(typeof(User), "u") };
+        var sut = new ExpressionParser(parameters, "DisplayName.Any(int(it) > 109)", null, null);
+
+        // Act
+        var result = sut.Parse(null);
+
+        // Assert
+        result.Should().NotBeNull();
+    }
+
     [Theory]
     [InlineData("string(\"\")", "")]
     [InlineData("string(\"a\")", "a")]
@@ -331,7 +345,7 @@ public void Parse_NullableShouldReturnNullable(string expression, object resultT
     [InlineData("Company.Equals(null, null)", "Equals(null, null)")]
     [InlineData("MainCompany.Name", "company.MainCompany.Name")]
     [InlineData("Name", "company.Name")]
-    [InlineData("company.Name","company.Name")]
+    [InlineData("company.Name", "company.Name")]
     [InlineData("DateTime", "company.DateTime")]
     public void Parse_When_PrioritizePropertyOrFieldOverTheType_IsTrue(string expression, string result)
     {

test/System.Linq.Dynamic.Core.Tests/QueryableTests.Is,OfType,As,Cast.cs

@@ -488,6 +488,32 @@ public void CastToType_FromStringToInt()
             castDynamic.Should().BeEquivalentTo(new[] { 1, 2 });
         }
 
+        // #440
+        [Fact]
+        public void CastToIntUsingParentheses()
+        {
+            // Assign
+            var qry = new[]
+            {
+                new User
+                {
+                    Id = 1,
+                    DisplayName = "" + (char) 109
+                },
+                new User
+                {
+                    Id = 2,
+                    DisplayName = "abc"
+                }
+            }.AsQueryable();
+
+            // Act
+            var result = qry.Where("DisplayName.Any(int(it) >= 109)").ToDynamicArray<User>();
+
+            // Assert
+            result.Should().HaveCount(1).And.Subject.First().Id.Should().Be(1);
+        }
+
         [Fact]
         public void CastToType_Dynamic_ActingOnIt()
         {