Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Linq/SqlClient/Query/SqlBooleanMismatchVisitor.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Data;
+
+namespace System.Data.Linq.SqlClient {
+    using System.Data.Linq;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// This visitor searches for places where 'Predicate' is found but a 'Bit'
+    /// was expected or vice versa. In response, it will call VisitBitExpectedPredicate
+    /// and VisitPredicateExpectedBit.
+    /// </summary>
+    internal abstract class SqlBooleanMismatchVisitor : SqlVisitor {
+
+        internal SqlBooleanMismatchVisitor() {
+        }
+
+        internal abstract SqlExpression ConvertValueToPredicate(SqlExpression valueExpression);
+        internal abstract SqlExpression ConvertPredicateToValue(SqlExpression predicateExpression);
+
+        internal override SqlSelect VisitSelect(SqlSelect select) {
+            select.From = this.VisitSource(select.From);
+            select.Where = this.VisitPredicate(select.Where);
+            for (int i = 0, n = select.GroupBy.Count; i < n; i++) {
+                select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
+            }
+            select.Having = this.VisitPredicate(select.Having);
+            for (int i = 0, n = select.OrderBy.Count; i < n; i++) {
+                select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
+            }
+            select.Top = this.VisitExpression(select.Top);
+            select.Row = (SqlRow)this.Visit(select.Row);
+
+            // don't visit selection
+            //select.Selection = this.VisitExpression(select.Selection);
+
+            return select;
+        }
+
+        internal override SqlSource VisitJoin(SqlJoin join) {
+            join.Left = this.VisitSource(join.Left);
+            join.Right = this.VisitSource(join.Right);
+            join.Condition = this.VisitPredicate(join.Condition);
+            return join;
+        }
+
+        internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
+            if (uo.NodeType.IsUnaryOperatorExpectingPredicateOperand()) {
+                uo.Operand = this.VisitPredicate(uo.Operand);
+            } else {
+                uo.Operand = this.VisitExpression(uo.Operand);
+            }
+            return uo;
+        }
+
+        internal override SqlExpression VisitBinaryOperator(SqlBinary bo) {
+            if (bo.NodeType.IsBinaryOperatorExpectingPredicateOperands()) {
+                bo.Left = this.VisitPredicate(bo.Left);
+                bo.Right = this.VisitPredicate(bo.Right);
+            } else {
+                bo.Left = this.VisitExpression(bo.Left);
+                bo.Right = this.VisitExpression(bo.Right);
+            }
+
+            return bo;
+        }
+
+        internal override SqlStatement VisitAssign(SqlAssign sa) {
+            // L-Value of assign is never a 'Bit' nor a 'Predicate'.
+            sa.LValue = this.VisitExpression(sa.LValue);
+            sa.RValue = this.VisitExpression(sa.RValue);
+            return sa;
+        }
+
+        internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) {
+            for (int i = 0, n = c.Whens.Count; i < n; i++) {
+                SqlWhen when = c.Whens[i];
+                when.Match = this.VisitPredicate(when.Match);
+                when.Value = this.VisitExpression(when.Value);
+            }
+            c.Else = this.VisitExpression(c.Else);
+            return c;
+        }
+
+        internal override SqlExpression VisitLift(SqlLift lift) {
+            lift.Expression = base.VisitExpression(lift.Expression);
+            return lift;
+        }
+
+        /// <summary>
+        /// If an expression is type 'Bit' but a 'Predicate' is expected then 
+        /// call 'VisitBitExpectedPredicate'.
+        /// </summary>
+        internal SqlExpression VisitPredicate(SqlExpression exp) {
+            exp = (SqlExpression)base.Visit(exp);
+            if (exp != null) {
+                if (!IsPredicateExpression(exp)) {
+                    exp = ConvertValueToPredicate(exp);
+                }
+            }
+            return exp;
+        }
+
+        /// <summary>
+        /// Any remaining calls to VisitExpression expect a 'Bit' when there's
+        /// a boolean expression.
+        /// </summary>
+        internal override SqlExpression VisitExpression(SqlExpression exp) {
+            exp = (SqlExpression)base.Visit(exp);
+            if (exp != null) {
+                if (IsPredicateExpression(exp)) {
+                    exp = ConvertPredicateToValue(exp);
+                }
+            }
+            return exp;
+        }
+
+        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
+        private static bool IsPredicateExpression(SqlExpression exp) {
+            switch (exp.NodeType) {
+                case SqlNodeType.And:
+                case SqlNodeType.Or:
+                case SqlNodeType.Not:
+                case SqlNodeType.Not2V:
+                case SqlNodeType.EQ:
+                case SqlNodeType.EQ2V:
+                case SqlNodeType.NE:
+                case SqlNodeType.NE2V:
+                case SqlNodeType.GE:
+                case SqlNodeType.GT:
+                case SqlNodeType.LE:
+                case SqlNodeType.LT:
+                case SqlNodeType.Exists:
+                case SqlNodeType.Between:
+                case SqlNodeType.In:
+                case SqlNodeType.Like:
+                case SqlNodeType.IsNotNull:
+                case SqlNodeType.IsNull:
+                    return true;
+                case SqlNodeType.Lift:
+                    return IsPredicateExpression(((SqlLift)exp).Expression);
+                default:
+                    return false;
+            }
+        }
+    }
+}