Support implicit boolean operator for logical operations (And, Or) (#806)

Author: StefH

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

@@ -2351,47 +2351,82 @@ private void CheckAndPromoteOperand(Type signatures, string opName, ref Expressi
         expr = args[0];
     }
 
-    private static string? GetOverloadedOperationName(TokenId tokenId)
+    private bool TryGetOverloadedEqualityOperator(TokenId tokenId, ref Expression left, ref Expression right, ref Expression[] args)
     {
-        switch (tokenId)
+        if (tokenId is TokenId.DoubleEqual or TokenId.Equal)
         {
-            case TokenId.DoubleEqual:
-            case TokenId.Equal:
-                return "op_Equality";
-
-            case TokenId.ExclamationEqual:
-                return "op_Inequality";
+            const string method = "op_Equality";
+            return _methodFinder.ContainsMethod(left.Type, method, true, null, ref args) ||
+                   _methodFinder.ContainsMethod(right.Type, method, true, null, ref args);
+        }
 
-            default:
-                return null;
+        if (tokenId is TokenId.ExclamationEqual or TokenId.LessGreater)
+        {
+            const string method = "op_Inequality";
+            return _methodFinder.ContainsMethod(left.Type, method, true, null, ref args) ||
+                   _methodFinder.ContainsMethod(right.Type, method, true, null, ref args);
         }
+
+        return false;
     }
 
-    private void CheckAndPromoteOperands(Type signatures, TokenId opId, string opName, ref Expression left, ref Expression right, int errorPos)
+    private bool TryGetOverloadedImplicitOperator(TokenId tokenId, ref Expression left, ref Expression right)
     {
-        Expression[] args = { left, right };
+        const string methodName = "op_Implicit";
+        if (tokenId is not (TokenId.Ampersand or TokenId.DoubleAmpersand or TokenId.Bar or TokenId.DoubleBar))
+        {
+            return false;
+        }
+
+        Expression? expression = null;
+        var overloadedImplicitOperatorFound = false;
 
-        // support operator overloading
-        var nativeOperation = GetOverloadedOperationName(opId);
-        bool found = false;
+        // If the left is not a boolean, try to find the "op_Implicit" method on the left which takes the left as parameter and returns a boolean.
+        if (left.Type != typeof(bool))
+        {
+            var args = new[] { left };
+            if (_methodFinder.FindMethod(left.Type, methodName, true, ref expression, ref args, out var methodBase) > 0 && methodBase is MethodInfo methodInfo && methodInfo.ReturnType == typeof(bool))
+            {
+                left = Expression.Call(methodInfo, left);
+                overloadedImplicitOperatorFound = true;
+            }
+        }
 
-        if (nativeOperation != null)
+        // If the right is not a boolean, try to find the "op_Implicit" method on the right which takes the right as parameter and returns a boolean.
+        if (right.Type != typeof(bool))
         {
-            // first try left operand's equality operators
-            found = _methodFinder.ContainsMethod(left.Type, nativeOperation, true, null, ref args);
-            if (!found)
+            var args = new[] { right };
+            if (_methodFinder.FindMethod(right.Type, methodName, true, ref expression, ref args, out var methodBase) > 0 && methodBase is MethodInfo methodInfo && methodInfo.ReturnType == typeof(bool))
             {
-                found = _methodFinder.ContainsMethod(right.Type, nativeOperation, true, null, ref args);
+                right = Expression.Call(methodInfo, right);
+                overloadedImplicitOperatorFound = true;
             }
         }
 
-        if (!found && !_methodFinder.ContainsMethod(signatures, "F", false, null, ref args))
+        return overloadedImplicitOperatorFound;
+    }
+
+    private void CheckAndPromoteOperands(Type signatures, TokenId opId, string opName, ref Expression left, ref Expression right, int errorPos)
+    {
+        Expression[] args = { left, right };
+
+        // 1. Try to find the Equality/Inequality operator
+        // 2. Try to find the method with the given signature
+        if (TryGetOverloadedEqualityOperator(opId, ref left, ref right, ref args) || _methodFinder.ContainsMethod(signatures, "F", false, null, ref args))
+        {
+            left = args[0];
+            right = args[1];
+
+            return;
+        }
+
+        // 3. Try to find the Implicit operator
+        if (TryGetOverloadedImplicitOperator(opId, ref left, ref right))
         {
-            throw IncompatibleOperandsError(opName, left, right, errorPos);
+            return;
         }
 
-        left = args[0];
-        right = args[1];
+        throw IncompatibleOperandsError(opName, left, right, errorPos);
     }
 
     private static Exception IncompatibleOperandError(string opName, Expression expr, int errorPos)

src/System.Linq.Dynamic.Core/Tokenizer/TokenId.cs

@@ -1,49 +1,125 @@
 #pragma warning disable CS1591
-namespace System.Linq.Dynamic.Core.Tokenizer
+namespace System.Linq.Dynamic.Core.Tokenizer;
+
+/// <summary>
+/// TokenId which defines the text which is parsed.
+/// </summary>
+public enum TokenId
 {
-    /// <summary>
-    /// TokenId which defines the text which is parsed.
-    /// </summary>
-    public enum TokenId
-    {
-        Unknown,
-        End,
-        Identifier,
-        StringLiteral,
-        IntegerLiteral,
-        RealLiteral,
-        Exclamation,
-        Percent,
-        Ampersand,
-        OpenParen,
-        CloseParen,
-        OpenCurlyParen,
-        CloseCurlyParen,
-        Asterisk,
-        Plus,
-        Comma,
-        Minus,
-        Dot,
-        Slash,
-        Colon,
-        LessThan,
-        Equal,
-        GreaterThan,
-        Question,
-        OpenBracket,
-        CloseBracket,
-        Bar,
-        ExclamationEqual,
-        DoubleAmpersand,
-        LessThanEqual,
-        LessGreater,
-        DoubleEqual,
-        GreaterThanEqual,
-        DoubleBar,
-        DoubleGreaterThan,
-        DoubleLessThan,
-        NullCoalescing,
-        Lambda,
-        NullPropagation
-    }
-}
+    Unknown,
+
+
+    End,
+
+
+    Identifier,
+
+
+    StringLiteral,
+
+
+    IntegerLiteral,
+
+
+    RealLiteral,
+
+    // !
+    Exclamation,
+
+    // % (Modulus Operator)
+    Percent,
+
+    // &
+    Ampersand,
+
+    // (
+    OpenParen,
+
+    // )
+    CloseParen,
+
+    // {
+    OpenCurlyParen,
+
+    // }
+    CloseCurlyParen,
+
+    // *
+    Asterisk,
+
+    // +
+    Plus,
+
+    // ,
+    Comma,
+
+    // -
+    Minus,
+
+    // .
+    Dot,
+
+    // /
+    Slash,
+
+    // :
+    Colon,
+
+    // <
+    LessThan,
+
+    // =
+    Equal,
+
+    // >
+    GreaterThan,
+
+    // ?
+    Question,
+
+    // [
+    OpenBracket,
+
+    // ]
+    CloseBracket,
+
+    // |
+    Bar,
+
+    // !=
+    ExclamationEqual,
+
+    // &&
+    DoubleAmpersand,
+
+    // <=
+    LessThanEqual,
+
+    // <>
+    LessGreater,
+
+    // ==
+    DoubleEqual,
+
+
+    // >=
+    GreaterThanEqual,
+
+    // ||
+    DoubleBar,
+
+    // >> (Shift Operator)
+    DoubleGreaterThan,
+
+    // << (Shift Operator)
+    DoubleLessThan,
+
+    // ??
+    NullCoalescing,
+
+    // =>
+    Lambda,
+
+    // ?.
+    NullPropagation
+}

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

@@ -423,6 +423,36 @@ public void DynamicExpressionParser_ParseLambda_WithStructWithEquality(string qu
         Check.That(result.ToArray()[0]).Equals(expected[0]);
     }
 
+    // #626
+    [Theory]
+    [InlineData("BooleanVariable1 && Bool2", true)]
+    [InlineData("BooleanVariable1 || Bool2", true)]
+    [InlineData("BooleanVariable1 && Bool3", false)]
+    [InlineData("BooleanVariable1 || Bool3", true)]
+    [InlineData("BooleanVariable1 && BooleanVariable4", false)]
+    [InlineData("BooleanVariable1 || BooleanVariable4", true)]
+    public void DynamicExpressionParser_ParseLambda_WithStruct_UsingOperators(string query, bool expectedResult)
+    {
+        var x = new BooleanVariable(true) && new BooleanVariable(false);
+
+        // Assign
+        var model = new
+        {
+            BooleanVariable1 = new BooleanVariable(true),
+            Bool2 = true,
+            Bool3 = false,
+            BooleanVariable4 = new BooleanVariable(false)
+        };
+
+        // Act
+        var expr = DynamicExpressionParser.ParseLambda(model.GetType(), null, query);
+        var compiled = expr.Compile();
+        var result = compiled.DynamicInvoke(model);
+
+        // Assert
+        result.Should().Be(expectedResult);
+    }
+
     [Fact]
     public void DynamicExpressionParser_ParseLambda_ToList()
     {