Optimize Visitors (#105)

* Optimize Visitors

* Memoize GetGenericTypeDefinition()

* Revert Memoizing MakeDelegateType()

Author: SergeiPavlov

.editorconfig

@@ -35,7 +35,7 @@ indent_style = space
 tab_width = 2
 
 # New line preferences
-end_of_line = crlf
+end_of_line = lf
 insert_final_newline = false
 
 #### .NET Coding Conventions ####

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

@@ -30,7 +30,7 @@ public static Expression Visit(Expression exp, Func<T, Expression> visitor)
 
     protected override Expression Visit(Expression exp)
     {
-      if (exp is T && visitor!=null)
+      if (exp is T && visitor != null)
         exp = visitor((T) exp);
 
       return base.Visit(exp);
@@ -54,7 +54,7 @@ internal abstract class ExpressionVisitor
 
     protected virtual Expression Visit(Expression exp)
     {
-      if (exp==null)
+      if (exp == null)
         return null;
       switch (exp.NodeType) {
         case ExpressionType.Negate:
@@ -127,8 +127,8 @@ private Expression VisitBinary(BinaryExpression b)
       Expression left = Visit(b.Left);
       Expression right = Visit(b.Right);
       Expression conversion = Visit(b.Conversion);
-      if (left!=b.Left || right!=b.Right || conversion!=b.Conversion) {
-        if (b.NodeType==ExpressionType.Coalesce)
+      if (left != b.Left || right != b.Right || conversion != b.Conversion) {
+        if (b.NodeType == ExpressionType.Coalesce)
           return Expression.Coalesce(left, right, conversion as LambdaExpression);
         return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);
       }
@@ -154,16 +154,16 @@ private IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBin
       List<MemberBinding> list = null;
       for (int i = 0, n = original.Count; i < n; i++) {
         MemberBinding b = VisitBinding(original[i]);
-        if (list!=null)
+        if (list != null)
           list.Add(b);
-        else if (b!=original[i]) {
+        else if (b != original[i]) {
           list = new List<MemberBinding>(n);
           for (int j = 0; j < i; j++)
             list.Add(original[j]);
           list.Add(b);
         }
       }
-      if (list!=null)
+      if (list != null)
         return list;
       return original;
     }
@@ -173,7 +173,7 @@ private Expression VisitConditional(ConditionalExpression c)
       Expression test = Visit(c.Test);
       Expression ifTrue = Visit(c.IfTrue);
       Expression ifFalse = Visit(c.IfFalse);
-      if (test!=c.Test || ifTrue!=c.IfTrue || ifFalse!=c.IfFalse)
+      if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)
         return Expression.Condition(test, ifTrue, ifFalse);
       return c;
     }
@@ -191,7 +191,7 @@ private Expression VisitDefault(DefaultExpression d)
     private ElementInit VisitElementInitializer(ElementInit initializer)
     {
       IEnumerable<Expression> arguments = VisitExpressionList(initializer.Arguments);
-      if (arguments!=initializer.Arguments)
+      if (arguments != initializer.Arguments)
         return Expression.ElementInit(initializer.AddMethod, arguments);
       return initializer;
     }
@@ -201,16 +201,16 @@ private IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<
       List<ElementInit> list = null;
       for (int i = 0, n = original.Count; i < n; i++) {
         ElementInit init = VisitElementInitializer(original[i]);
-        if (list!=null)
+        if (list != null)
           list.Add(init);
-        else if (init!=original[i]) {
+        else if (init != original[i]) {
           list = new List<ElementInit>(n);
           for (int j = 0; j < i; j++)
             list.Add(original[j]);
           list.Add(init);
         }
       }
-      if (list!=null)
+      if (list != null)
         return list;
       return original;
     }
@@ -220,16 +220,16 @@ private IEnumerable<Expression> VisitExpressionList(ReadOnlyCollection<Expressio
       List<Expression> list = null;
       for (int i = 0, n = original.Count; i < n; i++) {
         var p = Visit(original[i]);
-        if (list!=null)
+        if (list != null)
           list.Add(p);
-        else if (p!=original[i]) {
+        else if (p != original[i]) {
           list = new List<Expression>(n);
           for (int j = 0; j < i; j++)
             list.Add(original[j]);
           list.Add(p);
         }
       }
-      if (list!=null)
+      if (list != null)
         return list.AsReadOnly();
       return original;
     }
@@ -238,15 +238,15 @@ private Expression VisitInvocation(InvocationExpression iv)
     {
       IEnumerable<Expression> args = VisitExpressionList(iv.Arguments);
       Expression expr = Visit(iv.Expression);
-      if (args!=iv.Arguments || expr!=iv.Expression)
+      if (args != iv.Arguments || expr != iv.Expression)
         return Expression.Invoke(expr, args);
       return iv;
     }
 
     private Expression VisitLambda(LambdaExpression lambda)
     {
       Expression body = Visit(lambda.Body);
-      if (body!=lambda.Body)
+      if (body != lambda.Body)
         return FastExpression.Lambda(lambda.Type, body, lambda.Parameters);
       return lambda;
     }
@@ -255,23 +255,24 @@ private Expression VisitListInit(ListInitExpression init)
     {
       NewExpression n = VisitNew(init.NewExpression);
       IEnumerable<ElementInit> initializers = VisitElementInitializerList(init.Initializers);
-      if (n!=init.NewExpression || initializers!=init.Initializers)
+      if (n != init.NewExpression || initializers != init.Initializers)
         return Expression.ListInit(n, initializers);
       return init;
     }
 
     private Expression VisitMemberAccess(MemberExpression m)
     {
-      Expression exp = Visit(m.Expression);
-      if (exp!=m.Expression)
+      var originalExpression = m.Expression;
+      Expression exp = Visit(originalExpression);
+      if (exp != originalExpression)
         return Expression.MakeMemberAccess(exp, m.Member);
       return m;
     }
 
     private MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
     {
       Expression e = Visit(assignment.Expression);
-      if (e!=assignment.Expression)
+      if (e != assignment.Expression)
         return Expression.Bind(assignment.Member, e);
       return assignment;
     }
@@ -280,23 +281,23 @@ private Expression VisitMemberInit(MemberInitExpression init)
     {
       NewExpression n = VisitNew(init.NewExpression);
       IEnumerable<MemberBinding> bindings = VisitBindingList(init.Bindings);
-      if (n!=init.NewExpression || bindings!=init.Bindings)
+      if (n != init.NewExpression || bindings != init.Bindings)
         return Expression.MemberInit(n, bindings);
       return init;
     }
 
     private MemberListBinding VisitMemberListBinding(MemberListBinding binding)
     {
       IEnumerable<ElementInit> initializers = VisitElementInitializerList(binding.Initializers);
-      if (initializers!=binding.Initializers)
+      if (initializers != binding.Initializers)
         return Expression.ListBind(binding.Member, initializers);
       return binding;
     }
 
     private MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
     {
       IEnumerable<MemberBinding> bindings = VisitBindingList(binding.Bindings);
-      if (bindings!=binding.Bindings)
+      if (bindings != binding.Bindings)
         return Expression.MemberBind(binding.Member, bindings);
       return binding;
     }
@@ -305,24 +306,24 @@ private Expression VisitMethodCall(MethodCallExpression m)
     {
       Expression obj = Visit(m.Object);
       IEnumerable<Expression> args = VisitExpressionList(m.Arguments);
-      if (obj!=m.Object || args!=m.Arguments)
+      if (obj != m.Object || args != m.Arguments)
         return Expression.Call(obj, m.Method, args);
       return m;
     }
 
     private NewExpression VisitNew(NewExpression nex)
     {
       IEnumerable<Expression> args = VisitExpressionList(nex.Arguments);
-      if (args!=nex.Arguments)
+      if (args != nex.Arguments)
         return Expression.New(nex.Constructor, args, nex.Members);
       return nex;
     }
 
     private Expression VisitNewArray(NewArrayExpression na)
     {
       IEnumerable<Expression> exprs = VisitExpressionList(na.Expressions);
-      if (exprs!=na.Expressions) {
-        if (na.NodeType==ExpressionType.NewArrayInit)
+      if (exprs != na.Expressions) {
+        if (na.NodeType == ExpressionType.NewArrayInit)
           return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
         return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
       }
@@ -337,15 +338,15 @@ private Expression VisitParameter(ParameterExpression p)
     private Expression VisitTypeIs(TypeBinaryExpression b)
     {
       Expression expr = Visit(b.Expression);
-      if (expr!=b.Expression)
+      if (expr != b.Expression)
         return Expression.TypeIs(expr, b.TypeOperand);
       return b;
     }
 
     private Expression VisitUnary(UnaryExpression u)
     {
       Expression operand = Visit(u.Operand);
-      if (operand!=u.Operand)
+      if (operand != u.Operand)
         return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);
       return u;
     }

Orm/Xtensive.Orm.Tests.Core/Reflection/TypeHelperTest.cs

@@ -349,7 +349,7 @@ public void GetNameAndAddSuffixTest()
       sName = t.GetShortName();
       Assert.AreEqual("A<Int32,String>+B<Boolean>", sName);
 
-      t = t.GetGenericTypeDefinition().GetGenericArguments()[2];
+      t = t.CachedGetGenericTypeDefinition().GetGenericArguments()[2];
       fName = t.GetFullName();
       Assert.AreEqual("T3", fName);
       sName = t.GetShortName();

Orm/Xtensive.Orm.Tests.Framework/Dynamic.cs

@@ -1,4 +1,4 @@
-//Copyright (C) Microsoft Corporation.  All rights reserved.
+//Copyright (C) Microsoft Corporation.  All rights reserved.
 
 using System.Collections.Generic;
 using System.Globalization;
@@ -7,6 +7,7 @@
 using System.Reflection.Emit;
 using System.Text;
 using System.Threading;
+using Xtensive.Reflection;
 
 namespace System.Linq.Dynamic
 {
@@ -1309,7 +1310,7 @@ private static Type FindGenericType(Type generic, Type type)
     {
       while (type != null && type != typeof (object))
       {
-        if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type;
+        if (type.IsGenericType && type.CachedGetGenericTypeDefinition() == generic) return type;
         if (generic.IsInterface)
         {
           foreach (Type intfType in type.GetInterfaces())
@@ -1417,7 +1418,7 @@ private static bool IsPredefinedType(Type type)
 
     private static bool IsNullableType(Type type)
     {
-      return type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Nullable<>);
+      return type.IsGenericType && type.CachedGetGenericTypeDefinition() == typeof (Nullable<>);
     }
 
     private static Type GetNonNullableType(Type type)

Orm/Xtensive.Orm.Tests/Linq/MemberCompilerProviderTest.cs

@@ -147,7 +147,7 @@ public void ArrayAndEnumerableOverloadTest()
       var eachEnumerable = typeof (EachExtensions)
         .GetMethods()
         .Single(method => method.GetParameterTypes()
-          .Any(type => type.IsGenericType && type.GetGenericTypeDefinition()==typeof(IEnumerable<>)))
+          .Any(type => type.IsGenericType && type.CachedGetGenericTypeDefinition()==typeof(IEnumerable<>)))
         .MakeGenericMethod(typeof (int));
       var eachEnumerableCompiler = provider.GetCompiler(eachEnumerable);
       Assert.AreEqual("EachInEnumerable", eachEnumerableCompiler.Invoke(null, dummy));

Orm/Xtensive.Orm.Tests/Linq/QueryDumper.cs

@@ -228,20 +228,20 @@ private void CreateNodeTree(List<object> values, ref XmlDocument document, strin
         var depth = 1;
         XmlNode itemNode = document.CreateElement("Item" + itemIndex);
 
-        if (value==null || !value.GetType().IsGenericType || (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition()!=typeof (Grouping<,>))) {
+        if (value == null || !value.GetType().IsGenericType || (value.GetType().IsGenericType && value.GetType().CachedGetGenericTypeDefinition() != typeof(Grouping<,>))) {
           itemNode = document.CreateElement("Item" + itemIndex);
           itemIndex++;
           parentNode.AppendChild(itemNode);
         }
 
         if (value==null || ((GetMemberType(value.GetType())==MemberType.Primitive
           || GetMemberType(value.GetType())==MemberType.Unknown) && !value.GetType().IsGenericType)
-            || (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition()!=typeof (Grouping<,>))
+            || (value.GetType().IsGenericType && value.GetType().CachedGetGenericTypeDefinition()!=typeof (Grouping<,>))
               && (GetMemberType(value.GetType())==MemberType.Primitive
                 || GetMemberType(value.GetType())==MemberType.Unknown))
           depth = AddNode(value, null, ref document, itemNode, depth);
 
-        else if (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition()==typeof (Grouping<,>)) {
+        else if (value.GetType().IsGenericType && value.GetType().CachedGetGenericTypeDefinition()==typeof (Grouping<,>)) {
           var exactValue = (IEnumerable) value;
           foreach (var val in exactValue) {
             itemNode = document.CreateElement("Item" + itemIndex);
@@ -299,8 +299,8 @@ private int AddNode(object value, PropertyInfo property, ref XmlDocument documen
 
       else {
         if (property.PropertyType.IsGenericType &&
-          (property.PropertyType.GetGenericTypeDefinition()==typeof (IQueryable<>)
-            || (property.PropertyType.GetGenericTypeDefinition()==typeof (IEnumerable<>)))) {
+          (property.PropertyType.CachedGetGenericTypeDefinition() == typeof(IQueryable<>)
+            || (property.PropertyType.CachedGetGenericTypeDefinition() == typeof(IEnumerable<>)))) {
           var enumerable = (IEnumerable) property.GetValue(value, property.GetIndexParameters());
           var list = new List<object>();
           foreach (var o in enumerable)
@@ -556,19 +556,24 @@ private string KeyToString(object key)
     private static void EnumerateAll(IEnumerable enumerable)
     {
       foreach (var o in enumerable)
-        if (o!=null) {
-          if (o.GetType().IsGenericType && (o.GetType().GetGenericTypeDefinition()==typeof (IQueryable<>)
-            || o.GetType().GetGenericTypeDefinition()==typeof (IEnumerable<>)
-            || o.GetType().GetGenericTypeDefinition()==typeof (SubQuery<>)
-            || o.GetType().GetGenericTypeDefinition()==typeof (Grouping<,>)))
-            EnumerateAll((IEnumerable) o);
-          var properties = o.GetType().GetProperties();
+        if (o != null) {
+          var type = o.GetType();
+          if (type.IsGenericType) {
+            var genericTypeDefinition = type.CachedGetGenericTypeDefinition();
+            if (genericTypeDefinition == typeof(IQueryable<>)
+                || genericTypeDefinition == typeof(IEnumerable<>)
+                || genericTypeDefinition == typeof(SubQuery<>)
+              || genericTypeDefinition == typeof(Grouping<,>)) {
+              EnumerateAll((IEnumerable) o);
+            }
+          }
+          var properties = type.GetProperties();
           foreach (var info in properties) {
             if (info.PropertyType.IsGenericType && 
-              (info.PropertyType.GetGenericTypeDefinition()==typeof (IQueryable<>)
-              || info.PropertyType.GetGenericTypeDefinition()==typeof (IEnumerable<>)
-              || info.PropertyType.GetGenericTypeDefinition()==typeof (SubQuery<>)
-              || info.PropertyType.GetGenericTypeDefinition()==typeof (Grouping<,>)
+              (info.PropertyType.CachedGetGenericTypeDefinition()==typeof (IQueryable<>)
+              || info.PropertyType.CachedGetGenericTypeDefinition()==typeof (IEnumerable<>)
+              || info.PropertyType.CachedGetGenericTypeDefinition()==typeof (SubQuery<>)
+              || info.PropertyType.CachedGetGenericTypeDefinition()==typeof (Grouping<,>)
               ))
               EnumerateAll((IEnumerable) info.GetValue(o, null));
           }

Orm/Xtensive.Orm/Orm/Building/Builders/TypeBuilder.cs

@@ -417,7 +417,7 @@ private static bool IsAuxiliaryType(TypeInfo type)
       var underlyingBaseType = type.UnderlyingType.BaseType;
       return underlyingBaseType != null
         && underlyingBaseType.IsGenericType
-        && underlyingBaseType.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetItemOfT1T2;
+        && underlyingBaseType.CachedGetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetItemOfT1T2;
     }
 
     private ColumnInfo BuildDeclaredColumn(FieldInfo field)

Orm/Xtensive.Orm/Orm/Building/Builders/ValueTypeBuilder.cs

@@ -61,14 +61,16 @@ private static object AdjustValue(string fieldName, Type fieldType, object value
 #if NET6_0_OR_GREATER
 
       if (valueType == WellKnownTypes.TimeOnly) {
-        if (value is string timeOnlyString && !TimeOnly.TryParse(timeOnlyString, out var timeOnly)) {
+        TimeOnly timeOnly = default;
+        if (value is string timeOnlyString && !TimeOnly.TryParse(timeOnlyString, out timeOnly)) {
           throw FailToParseValue(fieldName, timeOnlyString);
         }
         return timeOnly;
       }
 
       if (valueType == WellKnownTypes.DateOnly) {
-        if (value is string dateOnlyString && !DateOnly.TryParse(dateOnlyString, out var dateOnly)) {
+        DateOnly dateOnly = default;
+        if (value is string dateOnlyString && !DateOnly.TryParse(dateOnlyString, out dateOnly)) {
           throw FailToParseValue(fieldName, dateOnlyString);
         }
         return dateOnly;