How to rewrite expression x=>!x to x=>x!=true and x=>x to x=>x==true

Question

Asume, that we expressions like this:

someIQueryable.Where(x => x.SomeBoolProperty)
someIQueryable.Where(x => !x.SomeBoolProperty)

I need to convert (rewrite using expression visitor) expressions like above to expressions like this:

someIQueryable.Where(x => x.SomeBoolProperty == true)
someIQueryable.Where(x => x.SomeBoolProperty != true)

NOTE: rewriter must work in more general case too, if we have more complex expressions:

 someIQueryable.Where((x => x.SomeBoolProperty && x.SomeIntProperty > 0) || !x.SomeOtherBoolProperty))

Answer 1

Something like:

static class BooleanComplexifier
{
    public static Expression<T> Process<T>(Expression<T> expression)
        where T : class
    {
        var body = expression.Body;
        if (body.Type == typeof(bool))
        {
            switch(body.NodeType)
            {
                case ExpressionType.Equal:
                case ExpressionType.NotEqual:
                case ExpressionType.GreaterThan:
                case ExpressionType.GreaterThanOrEqual:
                case ExpressionType.LessThan:
                case ExpressionType.LessThanOrEqual:
                    return expression;
                case ExpressionType.Not:
                    body = Expression.NotEqual(
                        ((UnaryExpression)body).Operand,
                        Expression.Constant(true));
                    break;
                default:
                        body = Expression.Equal(body,
                        Expression.Constant(true));
                    break;
            }
            return Expression.Lambda<T>(body, expression.Parameters);
        }
        return expression;
    }   
}

with:

Expression<Func<Foo, bool>> x = foo => foo.IsAlive,
    y = foo => !foo.IsAlive;

var a = BooleanComplexifier.Process(x); // foo => foo.IsAlive == true
var b = BooleanComplexifier.Process(y); // foo => foo.IsAlive != true
//...
class Foo
{
    public bool IsAlive { get;set; }
}

---

For more complex processing, an ExpressionVisitor may be necessary:

class BooleanComplexifier : ExpressionVisitor
{
    public static Expression<T> Process<T>(Expression<T> expression)
    {
        return (Expression<T>)new BooleanComplexifier().Visit(expression);
    }

    int bypass;
    protected override Expression VisitBinary(BinaryExpression node)
    {
        if (bypass == 0 && node.Type == typeof(bool))
        {
            switch (node.NodeType)
            {
                case ExpressionType.And: // bitwise & - different to &&
                case ExpressionType.Or: // bitwise | - different to ||
                case ExpressionType.Equal:
                case ExpressionType.NotEqual:
                    bypass++;
                    var result = base.VisitBinary(node);
                    bypass--;
                    return result;
            }
        }
        return base.VisitBinary(node);
    }
    protected override Expression VisitUnary(UnaryExpression node)
    {
        if (bypass == 0 && node.Type == typeof(bool))
        {
            switch(node.NodeType)
            {
                case ExpressionType.Not:
                    bypass++;
                    var result = Expression.NotEqual(
                        base.Visit(node.Operand),
                        Expression.Constant(true));
                    bypass--;
                    return result;
            }
        }
        return base.VisitUnary(node);
    }
    protected override Expression VisitMember(MemberExpression node)
    {
        if(bypass == 0 && node.Type == typeof(bool))
        {
            return Expression.Equal(
                base.VisitMember(node),
                Expression.Constant(true));
        }
        return base.VisitMember(node);
    }
}