Fix code formatting in the ExpressionExtensions class

Author: AlexUstinov

Orm/Xtensive.Orm/Orm/Linq/ExpressionExtensions.cs

@@ -5,7 +5,6 @@
 // Created:    2008.12.02
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -20,18 +19,21 @@ internal static class ExpressionExtensions
   {
     public static void EnsureKeyExpressionCompatible(this KeyExpression left, KeyExpression right, Expression expressionPart)
     {
-      if (left==null || right==null)
+      if (left==null || right==null) {
         return;
+      }
 
       if (left.EntityType.IsInterface || right.EntityType.IsInterface) {
-        if (left.EntityType.Key.EqualityIdentifier!=right.EntityType.Key.EqualityIdentifier)
+        if (left.EntityType.Key.EqualityIdentifier!=right.EntityType.Key.EqualityIdentifier) {
           throw new InvalidOperationException(string.Format(
             Strings.ExKeysOfXAndXNotCompatible, expressionPart.ToString(true), left.EntityType, right.EntityType));
+        }
       }
       else {
-        if (left.EntityType.Hierarchy!=right.EntityType.Hierarchy)
+        if (left.EntityType.Hierarchy!=right.EntityType.Hierarchy) {
           throw new InvalidOperationException(string.Format(
             Strings.ExEntitiesXAndXBelongToDifferentHierarchies, expressionPart.ToString(true), left.EntityType, right.EntityType));
+        }
       }
     }
 
@@ -41,173 +43,170 @@ public static bool IsAnonymousConstructor(this Expression expression)
       return expression.NodeType==ExpressionType.New && expression.GetMemberType()==MemberType.Anonymous;
     }
 
-    public static bool IsNewExpressionSupportedByStorage(this Expression expression)
-    {
-      return expression.NodeType==ExpressionType.New
-        && (expression.Type==WellKnownTypes.TimeSpan
-          || expression.Type==WellKnownTypes.DateTime
-          || expression.Type==WellKnownTypes.DateTimeOffset);
-    }
+    public static bool IsNewExpressionSupportedByStorage(this Expression expression) =>
+      expression.NodeType == ExpressionType.New
+      && (expression.Type == WellKnownTypes.TimeSpan
+        || expression.Type == WellKnownTypes.DateTime
+        || expression.Type == WellKnownTypes.DateTimeOffset);
 
-    public static bool IsConversionOperation(this Expression expression)
-    {
-      expression = expression.StripMarkers();
-      return expression.NodeType==ExpressionType.Convert || expression.NodeType==ExpressionType.TypeAs;
-    }
-
-    public static bool IsQuery(this Expression expression)
-    {
-      return expression.Type.IsOfGenericInterface(WellKnownInterfaces.QueryableOfT);
-    }
+    public static bool IsQuery(this Expression expression) =>
+      expression.Type.IsOfGenericInterface(WellKnownInterfaces.QueryableOfT);
 
-    public static bool IsLocalCollection(this Expression expression, TranslatorContext context)
-    {
-      return expression!=null
-        && !expression.IsProjection()
-        && !expression.IsGroupingExpression()
-        && !expression.IsEntitySet()
-        && !expression.IsSubqueryExpression()
-        && expression.Type!=WellKnownTypes.String
-        && expression.Type.IsOfGenericInterface(WellKnownInterfaces.EnumerableOfT)
-        && (IsEvaluableCollection(context, expression) || IsForeignQuery(expression));
-    }
+    public static bool IsLocalCollection(this Expression expression, TranslatorContext context) =>
+      expression != null
+      && !expression.IsProjection()
+      && !expression.IsGroupingExpression()
+      && !expression.IsEntitySet()
+      && !expression.IsSubqueryExpression()
+      && expression.Type != WellKnownTypes.String
+      && expression.Type.IsOfGenericInterface(WellKnownInterfaces.EnumerableOfT)
+      && (IsEvaluableCollection(context, expression) || IsForeignQuery(expression));
 
-    private static bool IsEvaluableCollection(TranslatorContext context, Expression expression)
-    {
-      return !expression.Type.IsOfGenericInterface(WellKnownInterfaces.QueryableOfT)
-        && context.Evaluator.CanBeEvaluated(expression);
-    }
+    private static bool IsEvaluableCollection(TranslatorContext context, Expression expression) =>
+      !expression.Type.IsOfGenericInterface(WellKnownInterfaces.QueryableOfT)
+      && context.Evaluator.CanBeEvaluated(expression);
 
     private static bool IsForeignQuery(Expression expression)
     {
       // Check for EnumerableQuery<T> and similar things
-      if (expression.NodeType==ExpressionType.Constant) {
-        var value = ((ConstantExpression) expression).Value as IQueryable;
-        if (value!=null) {
+      if (expression.NodeType == ExpressionType.Constant) {
+        if (((ConstantExpression) expression).Value is IQueryable value) {
           var type = value.GetType();
           if (type.IsGenericType) {
             var definition = type.GetGenericTypeDefinition();
-            return definition!=WellKnownInterfaces.QueryableOfT && definition!=WellKnownTypes.QueryableOfT;
+            return definition != WellKnownInterfaces.QueryableOfT && definition != WellKnownTypes.QueryableOfT;
           }
         }
       }
+
       return false;
     }
 
     public static bool IsItemProjector(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.ItemProjector;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.ItemProjector;
     }
 
     public static bool IsProjection(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.Projection;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.Projection;
     }
 
     public static bool IsEntitySetProjection(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.EntitySet;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.EntitySet;
     }
 
     public static bool IsGroupingExpression(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.Grouping;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.Grouping;
     }
 
     public static bool IsSubqueryExpression(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.SubQuery;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.SubQuery;
     }
 
     public static bool IsFullTextMatchExpression(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.FullText;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.FullText;
     }
 
     public static bool IsEntityExpression(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.Entity;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.Entity;
     }
 
     public static bool IsEntitySetExpression(this Expression expression)
     {
       expression = expression.StripMarkers();
-      return (ExtendedExpressionType) expression.NodeType==ExtendedExpressionType.EntitySet;
+      return (ExtendedExpressionType) expression.NodeType == ExtendedExpressionType.EntitySet;
     }
 
-    public static bool IsEntitySet(this Expression expression)
-    {
-      return expression.Type.IsGenericType
-        && expression.Type.GetGenericTypeDefinition()==WellKnownOrmTypes.EntitySetOfT;
-    }
-
-    public static Type GetGroupingKeyType(this Expression expression)
-    {
-      var newExpression = (NewExpression) expression.StripCasts();
-      return newExpression.Type.GetGenericArguments()[0];
-    }
+    public static bool IsEntitySet(this Expression expression) =>
+      expression.Type.IsGenericType
+      && expression.Type.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT;
 
     public static Expression StripMarkers(this Expression e)
     {
-      var ee = e as ExtendedExpression;
-      if (ee!=null && ee.ExtendedType==ExtendedExpressionType.Marker) {
+      if (e is ExtendedExpression ee && ee.ExtendedType == ExtendedExpressionType.Marker) {
         var marker = (MarkerExpression) ee;
         return marker.Target;
       }
+
       return e;
     }
 
     public static bool IsMarker(this Expression e)
     {
       e = e.StripCasts();
-      return (ExtendedExpressionType) e.NodeType==ExtendedExpressionType.Marker;
+      return (ExtendedExpressionType) e.NodeType == ExtendedExpressionType.Marker;
     }
 
     public static bool TryGetMarker(this Expression e, out MarkerType markerType)
     {
       e = e.StripCasts();
       markerType = MarkerType.None;
-      var result = (ExtendedExpressionType) e.NodeType==ExtendedExpressionType.Marker;
+      var result = (ExtendedExpressionType) e.NodeType == ExtendedExpressionType.Marker;
       if (result) {
         var marker = (MarkerExpression) e;
         markerType = marker.MarkerType;
       }
+
       return result;
     }
 
     public static MemberType GetMemberType(this Expression e)
     {
       e = e.StripMarkers();
       var type = e.Type;
-      if (WellKnownOrmTypes.Key.IsAssignableFrom(type))
+      if (WellKnownOrmTypes.Key.IsAssignableFrom(type)) {
         return MemberType.Key;
-      if (WellKnownOrmInterfaces.Entity.IsAssignableFrom(type))
+      }
+
+      if (WellKnownOrmInterfaces.Entity.IsAssignableFrom(type)) {
         return MemberType.Entity;
-      if (WellKnownOrmTypes.Structure.IsAssignableFrom(type))
+      }
+
+      if (WellKnownOrmTypes.Structure.IsAssignableFrom(type)) {
         return MemberType.Structure;
-      if (WellKnownOrmTypes.EntitySetBase.IsAssignableFrom(type))
+      }
+
+      if (WellKnownOrmTypes.EntitySetBase.IsAssignableFrom(type)) {
         return MemberType.EntitySet;
-      if (type.IsAnonymous())
+      }
+
+      if (type.IsAnonymous()) {
         return MemberType.Anonymous;
-      if (e.IsGroupingExpression())
+      }
+
+      if (e.IsGroupingExpression()) {
         return MemberType.Grouping;
-      if (e.IsSubqueryExpression())
+      }
+
+      if (e.IsSubqueryExpression()) {
         return MemberType.Subquery;
-      if (e.IsFullTextMatchExpression())
+      }
+
+      if (e.IsFullTextMatchExpression()) {
         return MemberType.FullTextMatch;
-      if (type.IsArray)
+      }
+
+      if (type.IsArray) {
         return MemberType.Array;
+      }
 
-      if ((ExtendedExpressionType) e.NodeType==ExtendedExpressionType.Field
-        || (ExtendedExpressionType) e.NodeType==ExtendedExpressionType.Column)
+      if ((ExtendedExpressionType) e.NodeType == ExtendedExpressionType.Field
+        || (ExtendedExpressionType) e.NodeType == ExtendedExpressionType.Column) {
         return MemberType.Primitive;
+      }
 
       return MemberType.Unknown;
     }
@@ -220,10 +219,12 @@ public static ParameterInfo[] GetConstructorParameters(this NewExpression expres
 
       // ReSharper disable ConditionIsAlwaysTrueOrFalse
       // ReSharper disable HeuristicUnreachableCode
-      if (expression.Constructor==null)
+      if (expression.Constructor == null) {
         return new ParameterInfo[0];
+      }
       // ReSharper restore ConditionIsAlwaysTrueOrFalse
       // ReSharper restore HeuristicUnreachableCode
+
       return expression.Constructor.GetParameters();
     }
   }