Optimization: Replace .In() by C#9 is/or operator for constants and == operator for fixed number of arguments (#45)

* Optimization: Replace .In() to non-allocating .IsOneOf() for fixed number of arguments

* Use C#9 is/or operator when possible

* Replace .IsOneOf() to explicit comparision expressions

* Refactor IsIndexerAccessor to avoid multiple getting of the same property

Author: SergeiPavlov

Directory.Build.props

@@ -38,6 +38,7 @@
     <NoLogo>true</NoLogo>
     <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <LangVersion>9.0</LangVersion>
     <SolutionDir Condition="$(SolutionDir) == ''">$([MSBuild]::EnsureTrailingSlash(
       $([MSBuild]::GetDirectoryNameOfFileAbove('$(MSBuildThisFileDirectory)', 'Orm.sln'))))</SolutionDir>
     <Configuration Condition="$(Configuration) == ''">Debug</Configuration>

Extensions/Xtensive.Orm.BulkOperations/Internals/SetOperation.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2020 Xtensive LLC.
+// Copyright (C) 2019-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -55,7 +55,7 @@ private void PreprocessStructures()
               Expression ex = setDescriptor.Expression;
               var call = ex as MethodCallExpression;
               if (call != null && call.Method.DeclaringType == typeof(Queryable) &&
-                call.Method.Name.In("First", "FirstOrDefault", "Single", "SingleOrDefault"))
+                call.Method.Name is "First" or "FirstOrDefault" or "Single" or "SingleOrDefault")
                 throw new NotSupportedException("Subqueries with structures are not supported");
               /*ex = call.Arguments[0];
         ParameterExpression parameter = Expression.Parameter(setDescriptor.Expression.Type, "parameter");
@@ -163,7 +163,7 @@ private void AddEntityValue(AddValueContext addContext)
       int i;
       if (methodCall!=null) {
         if (methodCall.Method.DeclaringType==typeof (QueryEndpoint) &&
-          methodCall.Method.Name.In("Single", "SingleOrDefault")) {
+          methodCall.Method.Name is "Single" or "SingleOrDefault") {
           object[] keys;
           if (methodCall.Arguments[0].Type==typeof (Key) || methodCall.Arguments[0].Type.IsSubclassOf(typeof (Key))) {
             var key = (Key) methodCall.Arguments[0].Invoke();
@@ -191,7 +191,7 @@ private void AddEntityValue(AddValueContext addContext)
           return;
         }
         if (methodCall.Method.DeclaringType==typeof (Queryable) &&
-          methodCall.Method.Name.In("Single", "SingleOrDefault", "First", "FirstOrDefault")) {
+          methodCall.Method.Name is "Single" or "SingleOrDefault" or "First" or "FirstOrDefault") {
           Expression exp = methodCall.Arguments[0];
           TypeInfo info = parent.GetTypeInfo(addContext.Field.ValueType);
           if (methodCall.Arguments.Count==2)

Orm/Xtensive.Orm/Orm/Building/Builders/ModelBuilder.cs

@@ -148,7 +148,7 @@ private void BuildPrefetchActions()
       var domain = context.Domain;
       foreach (var type in context.Model.Types.Entities) {
         var associations = type.GetOwnerAssociations()
-          .Where(a => a.OnOwnerRemove.In(OnRemoveAction.Cascade, OnRemoveAction.Clear))
+          .Where(a => a.OnOwnerRemove is OnRemoveAction.Cascade or OnRemoveAction.Clear)
           .ToList();
         if (associations.Count <= 0)
           continue;
@@ -307,7 +307,7 @@ private void BuildAssociations()
 
     private void TryAddForeignKeyIndex(AssociationInfo association)
     {
-      if (!association.Multiplicity.In(Multiplicity.OneToOne, Multiplicity.ZeroToOne))
+      if (!(association.Multiplicity is Multiplicity.OneToOne or Multiplicity.ZeroToOne))
         return;
       var typeDef = context.ModelDef.Types[association.OwnerType.UnderlyingType];
       var field = association.OwnerField;

Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2011-2020 Xtensive LLC.
+// Copyright (C) 2011-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Denis Krjuchkov
@@ -49,7 +49,7 @@ protected override Expression VisitBinary(BinaryExpression b)
     {
       // Detect f!=null and f==null for entity fields
 
-      if (!b.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual))
+      if (!(b.NodeType is ExpressionType.Equal or ExpressionType.NotEqual))
         return base.VisitBinary(b);
 
       var left = Visit(b.Left);

Orm/Xtensive.Orm/Orm/EntitySetBase.cs

@@ -874,14 +874,14 @@ private bool Contains(Key key, Entity item)
       var itemState = item == null
         ? PersistenceState.Synchronized
         : item.PersistenceState;
-      if (PersistenceState.New.In(ownerState, itemState) || State.IsFullyLoaded) {
+      if (PersistenceState.New == ownerState || PersistenceState.New == itemState || State.IsFullyLoaded) {
         return false;
       }
 
       // association check
       if (item != null) {
         var association = Field.GetAssociation(item.TypeInfo);
-        if (association.IsPaired && association.Multiplicity.In(Multiplicity.ManyToOne, Multiplicity.OneToMany)) {
+        if (association.IsPaired && association.Multiplicity is Multiplicity.ManyToOne or Multiplicity.OneToMany) {
           var candidate = (IEntity)item.GetFieldValue(association.Reversed.OwnerField);
           return candidate == Owner;
         }

Orm/Xtensive.Orm/Orm/Internals/Prefetch/Nodes/ExpressionMapBuilder.cs

@@ -95,9 +95,8 @@ private static void ValidateExpressionType(Expression e)
 
       e = e.StripCasts();
 
-      var isSupported = e.NodeType.In(
-        ExpressionType.MemberAccess, ExpressionType.Call, ExpressionType.New,
-        ExpressionType.Lambda, ExpressionType.Parameter);
+      var isSupported = e.NodeType is ExpressionType.MemberAccess or ExpressionType.Call or ExpressionType.New
+        or ExpressionType.Lambda or ExpressionType.Parameter;
 
       if (!isSupported)
         throw new NotSupportedException(string.Format(

Orm/Xtensive.Orm/Orm/Linq/Rewriters/NullComparsionRewriter.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2020 Xtensive LLC.
+// Copyright (C) 2012-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -23,7 +23,7 @@ protected override Expression VisitConditional(ConditionalExpression c)
       var ifTrue = Visit(c.IfTrue);
       var ifFalse = Visit(c.IfFalse);
 
-      if (test.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual)) {
+      if (test.NodeType is ExpressionType.Equal or ExpressionType.NotEqual) {
         var binaryExpression = (BinaryExpression) test;
         var left = binaryExpression.Left.StripCasts();
         var right = binaryExpression.Right.StripCasts();

Orm/Xtensive.Orm/Orm/Linq/Rewriters/PersistentIndexerRewriter.cs

@@ -21,7 +21,7 @@ internal class PersistentIndexerRewriter : ExpressionVisitor
     /// <exception cref="InvalidOperationException"><c>InvalidOperationException</c>.</exception>
     protected override Expression VisitBinary(BinaryExpression binaryExpression)
     {
-      if (binaryExpression.NodeType.In(ExpressionType.NotEqual, ExpressionType.Equal)) {
+      if (binaryExpression.NodeType is ExpressionType.NotEqual or ExpressionType.Equal) {
         Expression leftExpression = null;
         Expression rightExpression = null;
         if (IsIndexerAccessor(binaryExpression.Left))
@@ -88,13 +88,17 @@ private Expression GetMemberExpression(MethodCallExpression mc)
 
     private bool IsIndexerAccessor(Expression expression)
     {
-      if (expression.NodeType!=ExpressionType.Call)
+      if (expression.NodeType != ExpressionType.Call) {
         return false;
+      }
       var methodCallExpression = (MethodCallExpression) expression;
-      return methodCallExpression.Object!=null && 
-        methodCallExpression.Method.Name=="get_Item" && 
-        methodCallExpression.Method.DeclaringType.In(WellKnownOrmTypes.Persistent, WellKnownOrmInterfaces.Entity) &&
-        context.Evaluator.CanBeEvaluated(methodCallExpression.Arguments[0]);
+      if (methodCallExpression.Object == null) {
+        return false;
+      }
+      var method = methodCallExpression.Method;
+      return method.Name == "get_Item"
+        && method.DeclaringType switch { var declaringType => declaringType == WellKnownOrmTypes.Persistent || declaringType == WellKnownOrmInterfaces.Entity }
+        && context.Evaluator.CanBeEvaluated(methodCallExpression.Arguments[0]);
     }
 
     public static Expression Rewrite(Expression query, TranslatorContext context)

Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs

@@ -225,16 +225,14 @@ private static bool IsExpressionOf(Expression expression, Type type)
       return StripObjectCasts(expression).Type.StripNullable() == type;
     }
 
-    private static bool IsComparisonExpression(Expression expression)
-    {
-      return expression.NodeType.In(
-        ExpressionType.Equal,
-        ExpressionType.NotEqual,
-        ExpressionType.GreaterThan,
-        ExpressionType.LessThan,
-        ExpressionType.GreaterThanOrEqual,
-        ExpressionType.LessThanOrEqual);
-    }
+    private static bool IsComparisonExpression(Expression expression) =>
+      expression.NodeType is 
+        ExpressionType.Equal or
+        ExpressionType.NotEqual or
+        ExpressionType.GreaterThan or
+        ExpressionType.LessThan or
+        ExpressionType.GreaterThanOrEqual or
+        ExpressionType.LessThanOrEqual;
 
     private static Expression StripObjectCasts(Expression expression)
     {

Orm/Xtensive.Orm/Orm/Providers/SqlCompiler.Apply.cs

@@ -67,7 +67,7 @@ protected override SqlProvider VisitApply(ApplyProvider provider)
         providerVisitor.VisitCompilable(provider.Right);
         shouldUseQueryReference = usedOuterColumns.Any(calculatedColumnIndexes.Contains)
           || groupByIsUsed
-          || provider.Left.Type.In(ProviderType.Store, ProviderType.Include)
+          || provider.Left.Type is ProviderType.Store or ProviderType.Include
           || left.Header.Columns.Count!=left.Request.Statement.Columns.Count;
       }