Fix code formatting in the ExpressionEvaluator class

Author: AlexUstinov

Orm/Xtensive.Orm/Orm/Linq/ExpressionEvaluator.cs

@@ -12,7 +12,6 @@
 using Xtensive.Core;
 using Xtensive.Linq;
 using Xtensive.Orm.Internals;
-using Xtensive.Orm.Rse;
 using Xtensive.Reflection;
 using ExpressionVisitor = Xtensive.Linq.ExpressionVisitor;
 
@@ -34,24 +33,27 @@ internal sealed class ExpressionEvaluator : ExpressionVisitor
     /// <returns>
     ///   <see langword="true" /> if <paramref name="e"/> can be evaluated; otherwise, <see langword="false" />.
     /// </returns>
-    public bool CanBeEvaluated(Expression e)
-    {
-      return candidates.Contains(e);
-    }
+    public bool CanBeEvaluated(Expression e) => candidates.Contains(e);
 
     /// <summary>
     /// Evaluates the specified <paramref name="e"/> into <see cref="ConstantExpression"/>.
     /// </summary>
     /// <param name="e">The expression.</param>
     public static ConstantExpression Evaluate(Expression e)
     {
-      if (e==null)
+      if (e == null) {
         return null;
-      if (e.NodeType==ExpressionType.Constant)
+      }
+
+      if (e.NodeType == ExpressionType.Constant) {
         return (ConstantExpression) e;
-      Type type = e.Type;
-      if (type.IsValueType)
+      }
+
+      var type = e.Type;
+      if (type.IsValueType) {
         e = Expression.Convert(e, WellKnownTypes.Object);
+      }
+
       var lambda = FastExpression.Lambda<Func<object>>(e);
       var func = lambda.CachingCompile();
       return Expression.Constant(func(), type);
@@ -60,63 +62,73 @@ public static ConstantExpression Evaluate(Expression e)
     /// <inheritdoc/>
     protected override Expression Visit(Expression e)
     {
-      if (e!=null) {
-        bool saved = couldBeEvaluated;
+      if (e != null) {
+        var saved = couldBeEvaluated;
         couldBeEvaluated = true;
         base.Visit(e);
-        if (couldBeEvaluated)
-          if (CanEvaluateExpression(e))
+        if (couldBeEvaluated) {
+          if (CanEvaluateExpression(e)) {
             candidates.Add(e);
-          else
+          }
+          else {
             couldBeEvaluated = false;
+          }
+        }
+
         couldBeEvaluated &= saved;
       }
+
       return e;
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitUnknown(Expression e)
-    {
-      return e;
-    }
+    protected override Expression VisitUnknown(Expression e) => e;
 
     // Private methods
 
     private static bool CanEvaluateExpression(Expression expression)
     {
-      if (expression.Type==WellKnownOrmTypes.ApplyParameter)
+      if (expression.Type == WellKnownOrmTypes.ApplyParameter) {
         return false;
-      var cex = expression as ConstantExpression;
-      if (cex!=null) {
-        var query = cex.Value as IQueryable;
-        return query==null;
       }
-      if (expression.NodeType==ExpressionType.MemberAccess) {
+
+      if (expression is ConstantExpression cex) {
+        return !(cex.Value is IQueryable);
+      }
+
+      if (expression.NodeType == ExpressionType.MemberAccess) {
         var ma = (MemberExpression) expression;
-        if (ma.Expression==null)
+        if (ma.Expression == null) {
           return !WellKnownInterfaces.Queryable.IsAssignableFrom(ma.Type);
-        if (ma.Expression.Type.IsNullable() && ma.Member.Name == "Value")
+        }
+
+        if (ma.Expression.Type.IsNullable() && ma.Member.Name == "Value") {
           return false;
-        if (ma.Expression.NodeType==ExpressionType.Constant) {
+        }
+
+        if (ma.Expression.NodeType == ExpressionType.Constant) {
           var rfi = ma.Member as FieldInfo;
-          if (rfi!=null && rfi.FieldType.IsGenericType && WellKnownInterfaces.Queryable.IsAssignableFrom(rfi.FieldType))
+          if (rfi != null && rfi.FieldType.IsGenericType
+            && WellKnownInterfaces.Queryable.IsAssignableFrom(rfi.FieldType)) {
             return false;
+          }
         }
       }
-      var mc = expression as MethodCallExpression;
-#pragma warning disable 612,618
-      if (mc != null) {
+
+      if (expression is MethodCallExpression mc) {
         var methodInfo = mc.Method;
         if (methodInfo.DeclaringType == WellKnownTypes.Enumerable ||
-            methodInfo.DeclaringType == WellKnownTypes.Queryable ||
-            (methodInfo.DeclaringType == WellKnownOrmTypes.Query) && methodInfo.IsGenericMethod)
+          methodInfo.DeclaringType == WellKnownTypes.Queryable ||
+          methodInfo.DeclaringType == WellKnownOrmTypes.Query && methodInfo.IsGenericMethod) {
           return false;
+        }
       }
-#pragma warning restore 612,618
-      if (expression.NodeType==ExpressionType.Convert && expression.Type==WellKnownTypes.Object)
+
+      if (expression.NodeType == ExpressionType.Convert && expression.Type == WellKnownTypes.Object) {
         return true;
-      return expression.NodeType!=ExpressionType.Parameter &&
-        expression.NodeType!=ExpressionType.Lambda;
+      }
+
+      return expression.NodeType != ExpressionType.Parameter && expression.NodeType != ExpressionType.Lambda;
     }