Revert CachedGetGenericTypeDefinition()

SergeiPavlov · SergeiPavlov · commit c803af7a149f · 2023-08-25T10:43:20.000-07:00
diff --git a/Orm/Xtensive.Orm.Tests.Core/Reflection/TypeHelperTest.cs b/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.CachedGetGenericTypeDefinition().GetGenericArguments()[2];
+      t = t.GetGenericTypeDefinition().GetGenericArguments()[2];
       fName = t.GetFullName();
       Assert.AreEqual("T3", fName);
       sName = t.GetShortName();
diff --git a/Orm/Xtensive.Orm.Tests.Framework/Dynamic.cs b/Orm/Xtensive.Orm.Tests.Framework/Dynamic.cs
@@ -1310,7 +1310,7 @@ private static Type FindGenericType(Type generic, Type type)
     {
       while (type != null && type != typeof (object))
       {
-        if (type.IsGenericType && type.CachedGetGenericTypeDefinition() == generic) return type;
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type;
         if (generic.IsInterface)
         {
           foreach (Type intfType in type.GetInterfaces())
@@ -1418,7 +1418,7 @@ private static bool IsPredefinedType(Type type)
 
     private static bool IsNullableType(Type type)
     {
-      return type.IsGenericType && type.CachedGetGenericTypeDefinition() == typeof (Nullable<>);
+      return type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Nullable<>);
     }
 
     private static Type GetNonNullableType(Type type)
diff --git a/Orm/Xtensive.Orm.Tests/Linq/MemberCompilerProviderTest.cs b/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.CachedGetGenericTypeDefinition()==typeof(IEnumerable<>)))
+          .Any(type => type.IsGenericType && type.GetGenericTypeDefinition()==typeof(IEnumerable<>)))
         .MakeGenericMethod(typeof (int));
       var eachEnumerableCompiler = provider.GetCompiler(eachEnumerable);
       Assert.AreEqual("EachInEnumerable", eachEnumerableCompiler.Invoke(null, dummy));
diff --git a/Orm/Xtensive.Orm.Tests/Linq/QueryDumper.cs b/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().CachedGetGenericTypeDefinition() != typeof(Grouping<,>))) {
+        if (value == null || !value.GetType().IsGenericType || (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition() != 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().CachedGetGenericTypeDefinition()!=typeof (Grouping<,>))
+            || (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition()!=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().CachedGetGenericTypeDefinition()==typeof (Grouping<,>)) {
+        else if (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition()==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.CachedGetGenericTypeDefinition() == typeof(IQueryable<>)
-            || (property.PropertyType.CachedGetGenericTypeDefinition() == typeof(IEnumerable<>)))) {
+          (property.PropertyType.GetGenericTypeDefinition() == typeof(IQueryable<>)
+            || (property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))) {
           var enumerable = (IEnumerable) property.GetValue(value, property.GetIndexParameters());
           var list = new List<object>();
           foreach (var o in enumerable)
@@ -559,7 +559,7 @@ private static void EnumerateAll(IEnumerable enumerable)
         if (o != null) {
           var type = o.GetType();
           if (type.IsGenericType) {
-            var genericTypeDefinition = type.CachedGetGenericTypeDefinition();
+            var genericTypeDefinition = type.GetGenericTypeDefinition();
             if (genericTypeDefinition == typeof(IQueryable<>)
                 || genericTypeDefinition == typeof(IEnumerable<>)
                 || genericTypeDefinition == typeof(SubQuery<>)
@@ -570,10 +570,10 @@ private static void EnumerateAll(IEnumerable enumerable)
           var properties = type.GetProperties();
           foreach (var info in properties) {
             if (info.PropertyType.IsGenericType && 
-              (info.PropertyType.CachedGetGenericTypeDefinition()==typeof (IQueryable<>)
-              || info.PropertyType.CachedGetGenericTypeDefinition()==typeof (IEnumerable<>)
-              || info.PropertyType.CachedGetGenericTypeDefinition()==typeof (SubQuery<>)
-              || info.PropertyType.CachedGetGenericTypeDefinition()==typeof (Grouping<,>)
+              (info.PropertyType.GetGenericTypeDefinition()==typeof (IQueryable<>)
+              || info.PropertyType.GetGenericTypeDefinition()==typeof (IEnumerable<>)
+              || info.PropertyType.GetGenericTypeDefinition()==typeof (SubQuery<>)
+              || info.PropertyType.GetGenericTypeDefinition()==typeof (Grouping<,>)
               ))
               EnumerateAll((IEnumerable) info.GetValue(o, null));
           }
diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/TypeBuilder.cs b/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.CachedGetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetItemOfT1T2;
+        && underlyingBaseType.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetItemOfT1T2;
     }
 
     private ColumnInfo BuildDeclaredColumn(FieldInfo field)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/ExpressionExtensions.cs b/Orm/Xtensive.Orm/Orm/Linq/ExpressionExtensions.cs
@@ -76,7 +76,7 @@ private static bool IsForeignQuery(Expression expression)
         if (((ConstantExpression) expression).Value is IQueryable value) {
           var type = value.GetType();
           if (type.IsGenericType) {
-            var definition = type.CachedGetGenericTypeDefinition();
+            var definition = type.GetGenericTypeDefinition();
             return definition != WellKnownInterfaces.QueryableOfT && definition != WellKnownTypes.QueryableOfT;
           }
         }
@@ -135,7 +135,7 @@ public static bool IsEntitySetExpression(this Expression expression)
 
     public static bool IsEntitySet(this Expression expression) =>
       expression.Type switch {
-        var type => type.IsGenericType && type.CachedGetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT
+        var type => type.IsGenericType && type.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT
       };
 
     public static Expression StripMarkers(this Expression e)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs b/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs
@@ -313,16 +313,15 @@ private static CompilerKey GetCompilerKey(MemberInfo member)
 
       var targetType = canonicalMember.ReflectedType;
       if (targetType.IsGenericType) {
-        targetType = targetType.CachedGetGenericTypeDefinition();
-        if (canonicalMember is FieldInfo)
-          canonicalMember = targetType.GetField(canonicalMember.Name);
-        else if (canonicalMember is MethodInfo methodInfo) {
-          canonicalMember = GetCanonicalMethod(methodInfo, targetType.GetMethods());
+        if (!targetType.IsGenericTypeDefinition) {
+          targetType = targetType.GetGenericTypeDefinition();
         }
-        else if (canonicalMember is ConstructorInfo constructorInfo)
-          canonicalMember = GetCanonicalMethod(constructorInfo, targetType.GetConstructors());
-        else
-          canonicalMember = null;
+        canonicalMember = canonicalMember switch {
+          FieldInfo _ => targetType.GetField(canonicalMember.Name),
+          MethodInfo methodInfo => GetCanonicalMethod(methodInfo, targetType.GetMethods()),
+          ConstructorInfo constructorInfo => GetCanonicalMethod(constructorInfo, targetType.GetConstructors()),
+          _ => null
+        };
       }
 
       if (canonicalMember == null) {
@@ -331,10 +330,7 @@ private static CompilerKey GetCompilerKey(MemberInfo member)
 
       if (targetType.IsEnum) {
         var declaringType = canonicalMember.DeclaringType;
-        if (targetType != declaringType)
-          canonicalMember = GetCanonicalMethod((MethodInfo) canonicalMember, declaringType.GetMethods());
-        else
-          canonicalMember = GetCanonicalMethod((MethodInfo) canonicalMember, targetType.GetMethods());
+        canonicalMember = GetCanonicalMethod((MethodInfo) canonicalMember, targetType != declaringType ? declaringType.GetMethods() : targetType.GetMethods());
       }
 
       return new CompilerKey(canonicalMember);
diff --git a/Orm/Xtensive.Orm/Orm/Linq/QueryHelper.cs b/Orm/Xtensive.Orm/Orm/Linq/QueryHelper.cs
@@ -76,7 +76,7 @@ public static bool IsDirectEntitySetQuery(Expression entitySet)
       var wrapper = ((MemberExpression) owner).Expression;
       return wrapper.NodeType == ExpressionType.Constant
         && wrapper.Type.IsGenericType
-        && wrapper.Type.CachedGetGenericTypeDefinition() == typeof(OwnerWrapper<>);
+        && wrapper.Type.GetGenericTypeDefinition() == typeof(OwnerWrapper<>);
     }
 
     public static Expression CreateDirectEntitySetQuery(EntitySetBase entitySet)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Rewriters/EqualityRewriter.cs b/Orm/Xtensive.Orm/Orm/Linq/Rewriters/EqualityRewriter.cs
@@ -36,7 +36,7 @@ protected override Expression VisitMethodCall(MethodCallExpression mc)
 
       var interfaceMember = mc.Method.GetInterfaceMember();
       if (interfaceMember != null) {
-        if (interfaceMember.ReflectedType.IsGenericType && interfaceMember.ReflectedType.CachedGetGenericTypeDefinition() == typeof(IEquatable<>))
+        if (interfaceMember.ReflectedType.IsGenericType && interfaceMember.ReflectedType.GetGenericTypeDefinition() == typeof(IEquatable<>))
           return Expression.Equal(mc.Object, mc.Arguments[0]);
         return base.VisitMethodCall(mc);
       }
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs
@@ -1651,7 +1651,7 @@ private ProjectionExpression VisitSequence(Expression sequenceExpression, Expres
 
       if (sequence.IsLocalCollection(context)) {
         var sequenceType = (sequence.Type.IsGenericType
-          && sequence.Type.CachedGetGenericTypeDefinition() == typeof(Func<>))
+          && sequence.Type.GetGenericTypeDefinition() == typeof(Func<>))
           ? sequence.Type.GetGenericArguments()[0]
           : sequence.Type;
 
diff --git a/Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs b/Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs
@@ -51,7 +51,7 @@ private SqlExpression TryTranslateCompareExpression(BinaryExpression expression)
 
       // There no methods in IComparable except CompareTo so checking only DeclatingType.
       bool isCompareTo = methodType==WellKnownInterfaces.Comparable
-        || (methodType.IsGenericType && methodType.CachedGetGenericTypeDefinition() == WellKnownInterfaces.ComparableOfT);
+        || (methodType.IsGenericType && methodType.GetGenericTypeDefinition() == WellKnownInterfaces.ComparableOfT);
 
       bool isVbStringCompare = method.DeclaringType.FullName=="Microsoft.VisualBasic.CompilerServices.Operators" 
         && method.Name=="CompareString" 
diff --git a/Orm/Xtensive.Orm/Orm/Rse/Transformation/RedundantColumnRemover.cs b/Orm/Xtensive.Orm/Orm/Rse/Transformation/RedundantColumnRemover.cs
@@ -24,7 +24,7 @@ internal sealed class RedundantColumnRemover : ColumnMappingInspector
     private static readonly MethodInfo SelectMethodInfo = WellKnownTypes.Enumerable
       .GetMethods()
       .Single(methodInfo => methodInfo.Name == nameof(Enumerable.Select)
-        && methodInfo.GetParameters()[1].ParameterType.CachedGetGenericTypeDefinition() == WellKnownTypes.FuncOfTArgTResultType)
+        && methodInfo.GetParameters()[1].ParameterType.GetGenericTypeDefinition() == WellKnownTypes.FuncOfTArgTResultType)
       .CachedMakeGenericMethod(WellKnownOrmTypes.Tuple, WellKnownOrmTypes.Tuple);
 
     protected override Pair<CompilableProvider, List<int>> OverrideRightApplySource(ApplyProvider applyProvider, CompilableProvider provider, List<int> requestedMapping)
diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/UpgradeHintsProcessor.cs b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/UpgradeHintsProcessor.cs
@@ -179,7 +179,7 @@ private void BuildRenameFieldHintsForGenericTypes(
     {
       var genericTypeDefLookup = (
         from triplet in genericTypeMapping
-        group triplet by triplet.Item2.CachedGetGenericTypeDefinition()
+        group triplet by triplet.Item2.GetGenericTypeDefinition()
           into g
         select (Definition: g.Key, Instances: g.ToArray())
         ).ToDictionary(g => g.Definition);
@@ -550,7 +550,7 @@ public static ClassifiedCollection<Type, Pair<Type, Type[]>> GetGenericTypes(Dom
     {
       var genericTypes = new ClassifiedCollection<Type, Pair<Type, Type[]>>(pair => new[] { pair.First });
       foreach (var typeInfo in model.Types.Where(type => type.UnderlyingType.IsGenericType)) {
-        var typeDefinition = typeInfo.UnderlyingType.CachedGetGenericTypeDefinition();
+        var typeDefinition = typeInfo.UnderlyingType.GetGenericTypeDefinition();
         genericTypes.Add(new Pair<Type, Type[]>(typeDefinition, typeInfo.UnderlyingType.GetGenericArguments()));
       }
       return genericTypes;
diff --git a/Orm/Xtensive.Orm/Reflection/MethodHelper.cs b/Orm/Xtensive.Orm/Reflection/MethodHelper.cs
@@ -410,7 +410,7 @@ private static bool CheckMethod(MethodBase m, string name, string[] genericArgum
           isMatch = actualParameterType == requiredParameterType
             || (requiredParameterType.IsGenericTypeDefinition
                && actualParameterType.IsGenericType
-               && actualParameterType.CachedGetGenericTypeDefinition()==requiredParameterType)
+               && actualParameterType.GetGenericTypeDefinition()==requiredParameterType)
             || (requiredParameterType == AnyArrayPlaceholderType && actualParameterType.IsArray);
         }
         else {
diff --git a/Orm/Xtensive.Orm/Reflection/TypeHelper.cs b/Orm/Xtensive.Orm/Reflection/TypeHelper.cs
@@ -68,9 +68,6 @@ public int GetHashCode((Type, Type[]) obj)
 
     private static readonly ConcurrentDictionary<(MethodInfo, Type, Type), MethodInfo> GenericMethodInstances2 = new();
 
-    // .NET8+ caches GenericTypeDefinition
-    private static readonly ConcurrentDictionary<Type, Type> GenericTypeDefinitions = Environment.Version.Major < 8 ? new() : null;
-
     private static readonly ConcurrentDictionary<(Type, Type), Type> GenericTypeInstances1 = new();
 
     private static readonly ConcurrentDictionary<(Type, Type, Type), Type> GenericTypeInstances2 = new();
@@ -593,7 +590,7 @@ public static object Activate(this Type type, Type[] genericArguments, params ob
                 }
 
                 projectedConstraint = constraint
-                  .CachedGetGenericTypeDefinition()
+                  .GetGenericTypeDefinition()
                   .MakeGenericType(projectedConstraintArguments);
               }
 
@@ -938,9 +935,6 @@ public static bool IsGenericMethodSpecificationOf(this MethodInfo method, Method
         || method.Module == genericMethodDefinition.Module)
       && method.IsGenericMethod && genericMethodDefinition.IsGenericMethodDefinition;
 
-    public static Type CachedGetGenericTypeDefinition(this Type type) =>
-      GenericTypeDefinitions?.GetOrAdd(type, static t => t.GetGenericTypeDefinition()) ?? type.GetGenericTypeDefinition();
-
     public static MethodInfo CachedMakeGenericMethod(this MethodInfo genericDefinition, Type typeArgument) =>
       GenericMethodInstances1.GetOrAdd((genericDefinition, typeArgument), GenericMethodFactory1);
 

Original file line number	Diff line number	Diff line change
`@@ -1310,7 +1310,7 @@ private static Type FindGenericType(Type generic, Type type)`
`1310`	`1310`	`{`
`1311`	`1311`	`while (type != null && type != typeof (object))`
`1312`	`1312`	`{`
`1313`		`- if (type.IsGenericType && type.CachedGetGenericTypeDefinition() == generic) return type;`
	`1313`	`+ if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type;`
`1314`	`1314`	`if (generic.IsInterface)`
`1315`	`1315`	`{`
`1316`	`1316`	`foreach (Type intfType in type.GetInterfaces())`
`@@ -1418,7 +1418,7 @@ private static bool IsPredefinedType(Type type)`
`1418`	`1418`
`1419`	`1419`	`private static bool IsNullableType(Type type)`
`1420`	`1420`	`{`
`1421`		`- return type.IsGenericType && type.CachedGetGenericTypeDefinition() == typeof (Nullable<>);`
	`1421`	`+ return type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Nullable<>);`
`1422`	`1422`	`}`
`1423`	`1423`
`1424`	`1424`	`private static Type GetNonNullableType(Type type)`
Original file line number	Diff line number	Diff line change
`@@ -417,7 +417,7 @@ private static bool IsAuxiliaryType(TypeInfo type)`
`417`	`417`	`var underlyingBaseType = type.UnderlyingType.BaseType;`
`418`	`418`	`return underlyingBaseType != null`
`419`	`419`	`&& underlyingBaseType.IsGenericType`
`420`		`- && underlyingBaseType.CachedGetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetItemOfT1T2;`
	`420`	`+ && underlyingBaseType.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetItemOfT1T2;`
`421`	`421`	`}`
`422`	`422`
`423`	`423`	`private ColumnInfo BuildDeclaredColumn(FieldInfo field)`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public static bool IsDirectEntitySetQuery(Expression entitySet)`
`76`	`76`	`var wrapper = ((MemberExpression) owner).Expression;`
`77`	`77`	`return wrapper.NodeType == ExpressionType.Constant`
`78`	`78`	`&& wrapper.Type.IsGenericType`
`79`		`- && wrapper.Type.CachedGetGenericTypeDefinition() == typeof(OwnerWrapper<>);`
	`79`	`+ && wrapper.Type.GetGenericTypeDefinition() == typeof(OwnerWrapper<>);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`public static Expression CreateDirectEntitySetQuery(EntitySetBase entitySet)`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ protected override Expression VisitMethodCall(MethodCallExpression mc)`
`36`	`36`
`37`	`37`	`var interfaceMember = mc.Method.GetInterfaceMember();`
`38`	`38`	`if (interfaceMember != null) {`
`39`		`- if (interfaceMember.ReflectedType.IsGenericType && interfaceMember.ReflectedType.CachedGetGenericTypeDefinition() == typeof(IEquatable<>))`
	`39`	`+ if (interfaceMember.ReflectedType.IsGenericType && interfaceMember.ReflectedType.GetGenericTypeDefinition() == typeof(IEquatable<>))`
`40`	`40`	`return Expression.Equal(mc.Object, mc.Arguments[0]);`
`41`	`41`	`return base.VisitMethodCall(mc);`
`42`	`42`	`}`