Fix code (#115)

Author: StefH

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

@@ -519,13 +519,13 @@ Expression ParseIn()
                 var op = _textParser.CurrentToken;
 
                 _textParser.NextToken();
-                if (_textParser.CurrentToken.Id == TokenId.OpenParen) //literals (or other inline list)
+                if (_textParser.CurrentToken.Id == TokenId.OpenParen) // literals (or other inline list)
                 {
                     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)'
+                        // 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, try to convert the right-side also to an Enum.
@@ -537,14 +537,6 @@ Expression ParseIn()
                         // else, check for direct type match
                         else if (left.Type != right.Type)
                         {
-                            //check for nullable type match
-                            //if (!left.Type.GetTypeInfo().IsGenericType ||
-                            //    left.Type.GetGenericTypeDefinition() != typeof(Nullable<>) ||
-                            //    left.Type.GetTypeInfo().GetGenericTypeArguments()[0] != right.Type)
-                            //{
-                            //    throw ParseError(op.Pos, Res.ExpressionTypeMismatch, left.Type);
-                            //}
-
                             CheckAndPromoteOperands(typeof(IEqualitySignatures), "==", ref left, ref right, op.Pos);
                         }
 
@@ -558,32 +550,43 @@ Expression ParseIn()
                         }
 
                         if (_textParser.CurrentToken.Id == TokenId.End)
+                        {
                             throw ParseError(op.Pos, Res.CloseParenOrCommaExpected);
+                        }
                     }
                 }
-                else if (_textParser.CurrentToken.Id == TokenId.Identifier) //a single argument
+                else if (_textParser.CurrentToken.Id == TokenId.Identifier) // a single argument
                 {
                     Expression right = ParsePrimary();
 
                     if (!typeof(IEnumerable).IsAssignableFrom(right.Type))
+                    {
                         throw ParseError(_textParser.CurrentToken.Pos, Res.IdentifierImplementingInterfaceExpected, typeof(IEnumerable));
+                    }
 
                     var args = new[] { left };
 
-                    MethodBase containsSignature;
-                    if (FindMethod(typeof(IEnumerableSignatures), "Contains", false, args, out containsSignature) != 1)
+                    if (FindMethod(typeof(IEnumerableSignatures), "Contains", false, args, out MethodBase containsSignature) != 1)
+                    {
                         throw ParseError(op.Pos, Res.NoApplicableAggregate, "Contains");
+                    }
 
                     var typeArgs = new[] { left.Type };
+
                     args = new[] { right, left };
 
-                    var enumerableType = typeof(Enumerable);
-                    if (!typeof(IQueryable).IsAssignableFrom(right.Type))
-                        enumerableType = typeof(Queryable);
-                    accumulate = Expression.Call(enumerableType, containsSignature.Name, typeArgs, args);
+                    Type callType = typeof(Enumerable);
+                    if (!typeof(IQueryable).IsAssignableFrom(right.Type) && ContainsMethod(typeof(Queryable), containsSignature.Name, false, args))
+                    {
+                        callType = typeof(Queryable);
+                    }
+
+                    accumulate = Expression.Call(callType, containsSignature.Name, typeArgs, args);
                 }
                 else
+                {
                     throw ParseError(op.Pos, Res.OpenParenOrIdentifierExpected);
+                }
 
                 _textParser.NextToken();
             }
@@ -1608,8 +1611,7 @@ static Type FindGenericType(Type generic, Type type)
 
         Type FindType(string name)
         {
-            object type;
-            _keywords.TryGetValue(name, out type);
+            _keywords.TryGetValue(name, out object type);
             var result = type as Type;
             if (result != null)
                 return result;
@@ -1652,9 +1654,10 @@ Expression ParseAggregate(Expression instance, Type elementType, string methodNa
             _it = outerIt;
             _parent = oldParent;
 
-            MethodBase signature;
-            if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1)
+            if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out MethodBase signature) != 1)
+            {
                 throw ParseError(errorPos, Res.NoApplicableAggregate, methodName);
+            }
 
             Type[] typeArgs;
             if (new[] { "Min", "Max", "Select", "OrderBy", "OrderByDescending", "ThenBy", "ThenByDescending", "GroupBy" }.Contains(signature.Name))
@@ -1704,7 +1707,16 @@ Expression ParseAggregate(Expression instance, Type elementType, string methodNa
                 }
             }
 
-            return Expression.Call(isQueryable ? typeof(Queryable) : typeof(Enumerable), signature.Name, typeArgs, args);
+            Type callType = typeof(Enumerable);
+            if (isQueryable)
+            {
+                if (ContainsMethod(typeof(Queryable), signature.Name, false, args))
+                {
+                    callType = typeof(Queryable);
+                }
+            }
+
+            return Expression.Call(callType, signature.Name, typeArgs, args);
         }
 
         Expression[] ParseArgumentList()
@@ -1738,9 +1750,11 @@ Expression ParseElementAccess(Expression expr)
             int errorPos = _textParser.CurrentToken.Pos;
             _textParser.ValidateToken(TokenId.OpenBracket, Res.OpenParenExpected);
             _textParser.NextToken();
+
             Expression[] args = ParseArguments();
             _textParser.ValidateToken(TokenId.CloseBracket, Res.CloseBracketOrCommaExpected);
             _textParser.NextToken();
+
             if (expr.Type.IsArray)
             {
                 if (expr.Type.GetArrayRank() != 1 || args.Length != 1)
@@ -1750,20 +1764,17 @@ Expression ParseElementAccess(Expression expr)
                     throw ParseError(errorPos, Res.InvalidIndex);
                 return Expression.ArrayIndex(expr, index);
             }
-            else
+
+            switch (FindIndexer(expr.Type, args, out var mb))
             {
-                MethodBase mb;
-                switch (FindIndexer(expr.Type, args, out mb))
-                {
-                    case 0:
-                        throw ParseError(errorPos, Res.NoApplicableIndexer,
-                            GetTypeName(expr.Type));
-                    case 1:
-                        return Expression.Call(expr, (MethodInfo)mb, args);
-                    default:
-                        throw ParseError(errorPos, Res.AmbiguousIndexerInvocation,
-                            GetTypeName(expr.Type));
-                }
+                case 0:
+                    throw ParseError(errorPos, Res.NoApplicableIndexer,
+                        GetTypeName(expr.Type));
+                case 1:
+                    return Expression.Call(expr, (MethodInfo)mb, args);
+                default:
+                    throw ParseError(errorPos, Res.AmbiguousIndexerInvocation,
+                        GetTypeName(expr.Type));
             }
         }
 
@@ -1844,15 +1855,6 @@ static bool TryGetMemberName(Expression expression, out string memberName)
                 return true;
             }
 #endif
-            //#if !NET35
-            //            var dynamicExpression = expression as Expressions.DynamicExpression;
-            //            if (dynamicExpression != null)
-            //            {
-            //                memberName = ((GetMemberBinder)dynamicExpression.Binder).Name;
-            //                return true;
-            //            }
-            //#endif
-
             memberName = null;
             return false;
         }
@@ -1920,8 +1922,7 @@ void CheckAndPromoteOperand(Type signatures, string opName, ref Expression expr,
         {
             Expression[] args = { expr };
 
-            MethodBase method;
-            if (FindMethod(signatures, "F", false, args, out method) != 1)
+            if (!ContainsMethod(signatures, "F", false, args))
             {
                 throw IncompatibleOperandError(opName, expr, errorPos);
             }
@@ -1983,57 +1984,58 @@ static MemberInfo FindPropertyOrField(Type type, string memberName, bool staticA
 #endif
         }
 
+        bool ContainsMethod(Type type, string methodName, bool staticAccess, Expression[] args)
+        {
+            return FindMethod(type, methodName, staticAccess, args, out var _) == 1;
+        }
+
         int FindMethod(Type type, string methodName, bool staticAccess, Expression[] args, out MethodBase method)
         {
 #if !(NETFX_CORE || WINDOWS_APP || DOTNET5_1 || UAP10_0 || NETSTANDARD)
-            BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
-                (staticAccess ? BindingFlags.Static : BindingFlags.Instance);
+            BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly | (staticAccess ? BindingFlags.Static : BindingFlags.Instance);
             foreach (Type t in SelfAndBaseTypes(type))
             {
-                MemberInfo[] members = t.FindMembers(MemberTypes.Method,
-                    flags, Type.FilterNameIgnoreCase, methodName);
+                MemberInfo[] members = t.FindMembers(MemberTypes.Method, flags, Type.FilterNameIgnoreCase, methodName);
                 int count = FindBestMethod(members.Cast<MethodBase>(), args, out method);
-                if (count != 0) return count;
+                if (count != 0)
+                {
+                    return count;
+                }
             }
-            method = null;
-            return 0;
 #else
             foreach (Type t in SelfAndBaseTypes(type))
             {
                 MethodInfo[] methods = t.GetTypeInfo().DeclaredMethods.Where(x => (x.IsStatic || !staticAccess) && x.Name.ToLowerInvariant() == methodName.ToLowerInvariant()).ToArray();
                 int count = FindBestMethod(methods, args, out method);
-                if (count != 0) return count;
+                if (count != 0)
+                {
+                    return count;
+                }
             }
-
+#endif
             method = null;
             return 0;
-#endif
         }
 
         int FindIndexer(Type type, Expression[] args, out MethodBase method)
         {
             foreach (Type t in SelfAndBaseTypes(type))
             {
-                //#if !(NETFX_CORE || WINDOWS_APP || DOTNET5_1 || UAP10_0 || NETSTANDARD)
                 MemberInfo[] members = t.GetDefaultMembers();
-                //#else
-                //                MemberInfo[] members = new MemberInfo[0];
-                //#endif
                 if (members.Length != 0)
                 {
-                    IEnumerable<MethodBase> methods = members
-                        .OfType<PropertyInfo>().
+                    IEnumerable<MethodBase> methods = members.OfType<PropertyInfo>().
 #if !(NETFX_CORE || WINDOWS_APP || DOTNET5_1 || UAP10_0 || NETSTANDARD)
                         Select(p => (MethodBase)p.GetGetMethod()).
                         Where(m => m != null);
 #else
                     Select(p => (MethodBase)p.GetMethod);
 #endif
-
                     int count = FindBestMethod(methods, args, out method);
                     if (count != 0) return count;
                 }
             }
+
             method = null;
             return 0;
         }
@@ -2137,8 +2139,7 @@ Expression PromoteExpression(Expression expr, Type type, bool exact, bool conver
                 }
                 else
                 {
-                    string text;
-                    if (_literals.TryGetValue(ce, out text))
+                    if (_literals.TryGetValue(ce, out string text))
                     {
                         Type target = GetNonNullableType(type);
                         object value = null;

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

@@ -22,7 +22,7 @@ public void Entities_Page()
             var result = queryable.Page(page, pageSize).ToDynamicArray<Blog>();
 
             //Assert
-            Assert.Equal(true, any);
+            Assert.True(any);
             Assert.Equal(total, count);
             Assert.Equal(expected, result);
         }
@@ -51,4 +51,4 @@ public void Entities_PageResult()
             Assert.Equal(expectedResult, result.Queryable.ToDynamicArray<Blog>());
         }
     }
-}
+}

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

@@ -87,7 +87,7 @@ public void ExpressionTests_ArrayInitializer()
             var result4 = list.AsQueryable().SelectMany("new[] { new[] { it + 1, it + 2 }, new[] { it + 3, it + 4 } }");
 
             //Assert
-            Assert.Equal(result1.Count(), 0);
+            Assert.Equal(0, result1.Count());
             Assert.Equal(result2.Cast<int>(), list.SelectMany(item => new[] { item + 1, item + 2 }));
             Assert.Equal(result3.Cast<long>(), list.SelectMany(item => new long[] { item + 1, (byte)(item + 2), (short)(item + 3) }));
             Assert.Equal(result4.SelectMany("it").Cast<int>(), list.SelectMany(item => new[] { new[] { item + 1, item + 2 }, new[] { item + 3, item + 4 } }).SelectMany(item => item));
@@ -1547,7 +1547,7 @@ public void ExpressionTests_Uri()
             var result1 = qry.AsQueryable().Where("it = @0", new Uri("http://127.0.0.1"));
 
             //Assert
-            Assert.Equal(result1.Count(), 2);
+            Assert.Equal(2, result1.Count());
         }
 
         /// <summary>

test/System.Linq.Dynamic.Core.Tests/QueryableTests.GroupByMany.cs

@@ -22,9 +22,9 @@ public void GroupByMany_Dynamic_LambdaExpressions()
 
             var sel = lst.AsQueryable().GroupByMany(x => x.Item1, x => x.Item2);
 
-            Assert.Equal(sel.Count(), 2);
-            Assert.Equal(sel.First().Subgroups.Count(), 1);
-            Assert.Equal(sel.Skip(1).First().Subgroups.Count(), 2);
+            Assert.Equal(2, sel.Count());
+            Assert.Equal(1, sel.First().Subgroups.Count());
+            Assert.Equal(2, sel.Skip(1).First().Subgroups.Count());
         }
 
         [Fact]