Fix for parsing Guid and string in the same condition

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

@@ -188,7 +188,13 @@ public static Expression OptimizeStringForEqualityIfPossible(string text, Type t
 
         static MethodInfo GetStaticMethod(string methodName, Expression left, Expression right)
         {
-            return left.Type.GetMethod(methodName, new[] { left.Type, right.Type });
+            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;
         }
 
         static Expression GenerateStaticMethodCall(string methodName, Expression left, Expression right)

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

@@ -443,7 +443,7 @@ Expression ParseComparisonOperator()
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
                 Expression right = ParseShiftOperator();
-                bool isEquality = op.Id == TokenId.Equal || op.Id == TokenId.DoubleEqual || op.Id == TokenId.ExclamationEqual;
+                bool isEquality = op.Id == TokenId.Equal || op.Id == TokenId.DoubleEqual || op.Id == TokenId.ExclamationEqual || op.Id == TokenId.LessGreater;
 
                 if (isEquality && (!left.Type.GetTypeInfo().IsValueType && !right.Type.GetTypeInfo().IsValueType || left.Type == typeof(Guid) && right.Type == typeof(Guid)))
                 {

src/System.Linq.Dynamic.Core/Parser/SupportedOperands/IEqualitySignatures.cs

@@ -13,9 +13,13 @@ internal interface IEqualitySignatures : IRelationalSignatures
 
         void F(Guid x, Guid y);
         void F(Guid? x, Guid? y);
-        void F(Guid x, string y);
-        void F(Guid? x, string y);
-        void F(string x, Guid y);
-        void F(string x, Guid? y);
+
+        // Disabled 2 lines below according to unit test ParseLambda_With_Guid_Equals_Null
+        //void F(Guid x, string y);
+        //void F(Guid? x, string y);
+
+        // Disabled 2 lines below according to unit test ParseLambda_With_Null_Equals_Guid
+        //void F(string x, Guid y);
+        //void F(string x, Guid? y);
     }
 }

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

@@ -37,6 +37,57 @@ public class CustomClassWithStaticMethod
             public static int GetAge(int x) => x;
         }
 
+        public class CustomTextClass
+        {
+            public CustomTextClass(string origin)
+            {
+                Origin = origin;
+            }
+
+            public string Origin { get; }
+
+            public static implicit operator string(CustomTextClass customTextValue)
+            {
+                return customTextValue?.Origin;
+            }
+
+            public static implicit operator CustomTextClass(string origin)
+            {
+                return new CustomTextClass(origin);
+            }
+
+            public override string ToString()
+            {
+                return Origin;
+            }
+        }
+
+        public class TextHolder
+        {
+            public TextHolder(string name, CustomTextClass note)
+            {
+                Name = name;
+                Note = note;
+            }
+
+            public string Name { get; }
+
+            public CustomTextClass Note { get; }
+
+            public override string ToString()
+            {
+                return Name + " (" + Note + ")";
+            }
+        }
+
+        public static class StaticHelper
+        {
+            public static Guid? GetGuid(string name)
+            {
+                return Guid.NewGuid();
+            }
+        }
+
         private class TestCustomTypeProvider : AbstractDynamicLinqCustomTypeProvider, IDynamicLinkCustomTypeProvider
         {
             private HashSet<Type> _customTypes;
@@ -50,6 +101,7 @@ public virtual HashSet<Type> GetCustomTypes()
 
                 _customTypes = new HashSet<Type>(FindTypesMarkedWithDynamicLinqTypeAttribute(new[] { GetType().GetTypeInfo().Assembly }));
                 _customTypes.Add(typeof(CustomClassWithStaticMethod));
+                _customTypes.Add(typeof(StaticHelper));
                 return _customTypes;
             }
         }
@@ -452,5 +504,146 @@ public void ParseLambda_With_InnerStringLiteral()
             object result = del.DynamicInvoke(String.Empty);
             Check.That(result).IsEqualTo(originalTrueValue);
         }
+
+        [Fact]
+        public void ParseLambda_With_Guid_Equals_Null()
+        {
+            // Arrange
+            var user = new User();
+            Guid guidEmpty = Guid.Empty;
+            Guid someId = Guid.NewGuid();
+            string expressionText = $"iif(@0.Id == null, @0.Id == Guid.Parse(\"{someId}\"), Id == Id)";
+
+            // Act
+            var lambda = DynamicExpressionParser.ParseLambda(typeof(User), null, expressionText, user);
+            var boolLambda = lambda as Expression<Func<User, bool>>;
+            Assert.NotNull(boolLambda);
+
+            var del = lambda.Compile();
+            bool result = (bool) del.DynamicInvoke(user);
+
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void ParseLambda_With_Null_Equals_Guid()
+        {
+            // Arrange
+            var user = new User();
+            Guid guidEmpty = Guid.Empty;
+            Guid someId = Guid.NewGuid();
+            string expressionText = $"iif(null == @0.Id, @0.Id == Guid.Parse(\"{someId}\"), Id == Id)";
+
+            // Act
+            var lambda = DynamicExpressionParser.ParseLambda(typeof(User), null, expressionText, user);
+            var boolLambda = lambda as Expression<Func<User, bool>>;
+            Assert.NotNull(boolLambda);
+
+            var del = lambda.Compile();
+            bool result = (bool) del.DynamicInvoke(user);
+
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void ParseLambda_With_Guid_Equals_String()
+        {
+            // Arrange
+            Guid someId = Guid.NewGuid();
+            Guid anotherId = Guid.NewGuid();
+            var user = new User();
+            user.Id = someId;
+            Guid guidEmpty = Guid.Empty;
+            string expressionText = $"iif(@0.Id == \"{someId}\", Guid.Parse(\"{guidEmpty}\"), Guid.Parse(\"{anotherId}\"))";
+
+            // Act
+            var lambda = DynamicExpressionParser.ParseLambda(typeof(User), null, expressionText, user);
+            var guidLambda = lambda as Expression<Func<User, Guid>>;
+            Assert.NotNull(guidLambda);
+
+            var del = lambda.Compile();
+            Guid result = (Guid) del.DynamicInvoke(user);
+
+            // Assert
+            Assert.Equal(guidEmpty, result);
+        }
+
+        [Fact]
+        public void ParseLambda_With_Concat_String_CustomType()
+        {
+            // Arrange
+            string name = "name1";
+            string note = "note1";
+            var textHolder = new TextHolder(name, note);
+            string expressionText = $"Name + \" (\" + Note + \")\"";
+
+            // Act 1
+            var lambda = DynamicExpressionParser.ParseLambda(typeof(TextHolder), null, expressionText, textHolder);
+            var stringLambda = lambda as Expression<Func<TextHolder, string>>;
+
+            // Assert 1
+            Assert.NotNull(stringLambda);
+
+            // Act 2
+            var del = lambda.Compile();
+            string result = (string) del.DynamicInvoke(textHolder);
+
+            // Assert 2
+            Assert.Equal("name1 (note1)", result);
+        }
+
+        [Fact]
+        public void ParseLambda_With_Concat_CustomType_String()
+        {
+            // Arrange
+            string name = "name1";
+            string note = "note1";
+            var textHolder = new TextHolder(name, note);
+            string expressionText = $"Note + \" (\" + Name + \")\"";
+
+            // Act 1
+            var lambda = DynamicExpressionParser.ParseLambda(typeof(TextHolder), null, expressionText, textHolder);
+            var stringLambda = lambda as Expression<Func<TextHolder, string>>;
+
+            // Assert 1
+            Assert.NotNull(stringLambda);
+
+            // Act 2
+            var del = lambda.Compile();
+            string result = (string) del.DynamicInvoke(textHolder);
+
+            // Assert 2
+            Assert.Equal("note1 (name1)", result);
+        }
+
+        [Fact]
+        public void ParseLambda_With_Less_Greater()
+        {
+            var config = new ParsingConfig
+            {
+                CustomTypeProvider = new TestCustomTypeProvider()
+            };
+
+            // Arrange
+            Guid someId = Guid.NewGuid();
+            Guid anotherId = Guid.NewGuid();
+            var user = new User();
+            user.Id = someId;
+            Guid guidEmpty = Guid.Empty;
+            string expressionText = $"iif(@0.Id == StaticHelper.GetGuid(\"name\"), Guid.Parse(\"{guidEmpty}\"), Guid.Parse(\"{anotherId}\"))";
+
+            // Act
+            var lambda = DynamicExpressionParser.ParseLambda(config, typeof(User), null, expressionText, user);
+            var guidLambda = lambda as Expression<Func<User, Guid>>;
+            Assert.NotNull(guidLambda);
+
+            var del = lambda.Compile();
+            Guid result = (Guid) del.DynamicInvoke(user);
+
+            // Assert
+            Assert.Equal(anotherId, result);
+        }
     }
 }