Fix bitwise comparsion operators

The operators `-band` and `-bor` required conversion for `Enum` types.
The comparison is now performed on the underlying type and then
converted to the type of the lhs expression if applicable.

Author: SeeminglyScience

src/PSLambda/CompileVisitor.cs

@@ -244,9 +244,9 @@ public object VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)
                 case TokenKind.Or:
                     return OrElse(PSIsTrue(lhs), PSIsTrue(rhs));
                 case TokenKind.Band:
-                    return And(lhs, rhs);
+                    return PSBitwiseOperation(ExpressionType.And, lhs, rhs);
                 case TokenKind.Bor:
-                    return Or(lhs, rhs);
+                    return PSBitwiseOperation(ExpressionType.Or, lhs, rhs);
                 case TokenKind.Is:
                     if (rhsTypeConstant == null)
                     {

src/PSLambda/ExpressionUtils.cs

@@ -352,6 +352,39 @@ public static Expression PSDotDot(Expression lhs, Expression rhs)
                 PSConvertTo<int>(rhs));
         }
 
+        /// <summary>
+        /// Creates an <see cref="Expression" /> representing the evaluation of a bitwise comparision
+        /// operator from the PowerShell engine.
+        /// </summary>
+        /// <param name="expressionType">The expression operator.</param>
+        /// <param name="lhs">The <see cref="Expression" /> on the left hand side.</param>
+        /// <param name="rhs">The <see cref="Expression" /> on the right hand side.</param>
+        /// <returns>An <see cref="Expression" /> representing the operation.</returns>
+        public static Expression PSBitwiseOperation(
+            ExpressionType expressionType,
+            Expression lhs,
+            Expression rhs)
+        {
+            var resultType = lhs.Type;
+            if (typeof(Enum).IsAssignableFrom(lhs.Type))
+            {
+                lhs = Convert(lhs, Enum.GetUnderlyingType(lhs.Type));
+            }
+
+            if (typeof(Enum).IsAssignableFrom(rhs.Type))
+            {
+                rhs = Convert(rhs, Enum.GetUnderlyingType(rhs.Type));
+            }
+
+            var resultExpression = MakeBinary(expressionType, lhs, rhs);
+            if (resultType == resultExpression.Type)
+            {
+                return resultExpression;
+            }
+
+            return PSConvertTo(resultExpression, resultType);
+        }
+
         private static bool PSEqualsIgnoreCase(object first, object second)
         {
             return LanguagePrimitives.Compare(first, second, ignoreCase: true) == 0;

test/Operator.Tests.ps1

@@ -187,4 +187,15 @@ Describe 'operator tests' {
         (New-PSDelegate { 'this' -ceq 'that' }).Invoke() | Should -Be $false
         (New-PSDelegate { 'this' -ceq 'This' }).Invoke() | Should -Be $false
     }
+    It 'Bor' {
+        (New-PSDelegate { [Reflection.BindingFlags]::Instance -bor [Reflection.BindingFlags]::Public }).Invoke() |
+            Should -Be ([Reflection.BindingFlags]'Instance, Public')
+    }
+
+    It 'Band' {
+        $flags = [Reflection.BindingFlags]'Instance, Public'
+        (New-PSDelegate { $flags -band [Reflection.BindingFlags]::Public }).Invoke() |
+            Should -Be ([Reflection.BindingFlags]'Public')
+    }
+
 }