add some test cases

Author: huoshan12345

src/AspectCore.Core/Extensions/CollectionExtensions.cs

@@ -0,0 +1,15 @@
+// ReSharper disable once CheckNamespace
+namespace System.Collections.Generic
+{
+    internal static class CollectionExtensions
+    {
+#if NETSTANDARD2_0
+        public static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue)
+        {
+            return dictionary.TryGetValue(key, out var obj)
+                ? obj
+                : defaultValue;
+        }
+#endif
+    }
+}

src/AspectCore.Core/Extensions/MethodInfoExtensions.cs

@@ -27,11 +27,6 @@ public static IEnumerable<MethodInfo> GetInterfaceDeclarations(this MethodInfo m
             }
         }
 
-        public static bool IsOverriden(this MethodInfo method)
-        {
-            return method.GetBaseDefinition() != method;
-        }
-
         public static bool IsPreserveBaseOverride(this MethodInfo method, bool checkBase)
         {
             if (PreserveBaseOverridesAttribute is null)
@@ -55,6 +50,26 @@ public static bool IsPreserveBaseOverride(this MethodInfo method, bool checkBase
 
             return false;
         }
+
+        public static IEnumerable<MethodInfo> EnumerateBaseDefinition(this MethodInfo method)
+        {
+            var m = method;
+            while (true)
+            {
+                yield return m;
+
+                var b = m.GetBaseDefinition();
+                if (b == m || b == null)
+                    yield break;
+
+                m = b;
+            }
+        }
+
+        public static bool EqualAnyBaseDefinitionTo(this MethodInfo method, MethodInfo other)
+        {
+            return method.EnumerateBaseDefinition().Any(m => m == other);
+        }
     }
 }
 

src/AspectCore.Core/Extensions/TypeExtensions.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+// ReSharper disable once CheckNamespace
+namespace AspectCore.Extensions
+{
+    internal static class TypeExtensions
+    {
+        public readonly struct CovariantReturnMethodInfo
+        {
+            public readonly MethodInfo CovariantReturnMethod;
+            public readonly MethodInfo OverridenMethod;
+            public readonly HashSet<MethodInfo> InterfaceDeclarations;
+
+            public CovariantReturnMethodInfo(MethodInfo covariantReturnMethod, MethodInfo overridenMethod, HashSet<MethodInfo> interfaceDeclarations)
+            {
+                InterfaceDeclarations = interfaceDeclarations;
+                OverridenMethod = overridenMethod;
+                CovariantReturnMethod = covariantReturnMethod;
+            }
+        }
+
+        public static IReadOnlyList<CovariantReturnMethodInfo> GetCovariantReturnMethods(this Type type)
+        {
+            var result = new List<CovariantReturnMethodInfo>();
+            // No PreserveBaseOverridesAttribute means that the runtime does not support covariant return types.
+            if (MethodInfoExtensions.PreserveBaseOverridesAttribute is null)
+                return result;
+
+            var methods = type
+                .GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+                .GroupBy(m => m.IsPreserveBaseOverride(true))
+                .ToDictionary(m => m.Key, m => m.ToArray());
+
+            var covariantReturnMethods = methods.GetValueOrDefault(true, Array.Empty<MethodInfo>());
+            var otherMethods = methods.GetValueOrDefault(false, Array.Empty<MethodInfo>());
+
+            foreach (var covariantReturnMethod in covariantReturnMethods)
+            {
+                var overridenMethod = otherMethods.FirstOrDefault(m => Match(covariantReturnMethod, m));
+                if (overridenMethod is null)
+                    continue;
+
+                var interfaceDeclarations = covariantReturnMethod.GetInterfaceDeclarations().ToHashSet();
+                result.Add(new CovariantReturnMethodInfo(covariantReturnMethod, overridenMethod, interfaceDeclarations));
+            }
+
+            return result;
+
+            bool Match(MethodInfo covariantReturnMethod, MethodInfo other)
+            {
+                if (covariantReturnMethod.Name != other.Name)
+                    return false;
+
+                // return types should not be the same.
+                if (covariantReturnMethod.ReturnType == other.ReturnType)
+                    return false;
+
+                if (other.ReturnType.IsAssignableFrom(covariantReturnMethod.ReturnType) == false)
+                    return false;
+
+                var params1 = covariantReturnMethod.GetParameters();
+                var params2 = other.GetParameters();
+
+                if (params1.Length != params2.Length)
+                    return false;
+
+                foreach (var (p1, p2) in params1.Zip(params2))
+                {
+                    if (p1.ParameterType != p2.ParameterType)
+                        return false;
+                }
+
+                var isGeneric = covariantReturnMethod.IsGenericMethod;
+                if (isGeneric != other.IsGenericMethod)
+                    return false;
+
+                if (isGeneric)
+                {
+                    var args1 = covariantReturnMethod.GetGenericArguments();
+                    var args2 = other.GetGenericArguments();
+                    if (args1.Length != args2.Length)
+                        return false;
+
+                    foreach (var (a1, a2) in args1.Zip(args2))
+                    {
+                        if (a1 != a2)
+                            return false;
+                    }
+                }
+
+                return true;
+            }
+        }
+    }
+}

src/AspectCore.Core/Utils/ProxyGeneratorUtils.cs

@@ -162,29 +162,6 @@ private Type CreateClassProxyInternal(string name, Type serviceType, Type implTy
             return typeDesc.Compile();
         }
 
-        // key: covariant return method
-        // value: interface method declarations
-        internal static IReadOnlyDictionary<MethodInfo, HashSet<MethodInfo>> GetCovariantReturnMethodMap(Type implType)
-        {
-            var result = new Dictionary<MethodInfo, HashSet<MethodInfo>>();
-            // No PreserveBaseOverridesAttribute means that the runtime does not support covariant return types.
-            if (AspectCore.Extensions.MethodInfoExtensions.PreserveBaseOverridesAttribute is null)
-                return result;
-
-            var covariantReturnMethods = implType
-                .GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
-                .Where(m => m.IsPreserveBaseOverride(true))
-                .ToHashSet();
-
-            foreach (var method in covariantReturnMethods)
-            {
-                var interfaceDeclarations = method.GetInterfaceDeclarations().ToHashSet();
-                result[method] = interfaceDeclarations;
-            }
-
-            return result;
-        }
-
         private class ProxyNameUtils
         {
             private readonly Dictionary<string, ProxyNameIndex> _indexes = new Dictionary<string, ProxyNameIndex>();
@@ -415,26 +392,36 @@ internal static MethodBuilder DefineInterfaceImplMethod(MethodInfo method, TypeB
 
             internal static void DefineInterfaceProxyMethods(Type interfaceType, Type targetType, Type[] additionalInterfaces, TypeDesc typeDesc)
             {
-                var covariantReturnMethodMap = GetCovariantReturnMethodMap(targetType);
+                var covariantReturnMethodMap = targetType.GetCovariantReturnMethods();
                 foreach (var method in interfaceType.GetTypeInfo().DeclaredMethods.Where(x => !x.IsPropertyBinding()))
                 {
-                    var covariantReturnMethod = covariantReturnMethodMap.FirstOrDefault(m => m.Value.Contains(method)).Key;
+                    var covariantReturnMethod = covariantReturnMethodMap
+                        .FirstOrDefault(m => m.InterfaceDeclarations.Contains(method))
+                        .CovariantReturnMethod;
+
                     DefineInterfaceMethod(method, targetType, typeDesc, covariantReturnMethod);
                 }
                 foreach (var item in additionalInterfaces)
                 {
                     foreach (var method in item.GetTypeInfo().DeclaredMethods.Where(x => !x.IsPropertyBinding()))
                     {
-                        var covariantReturnMethod = covariantReturnMethodMap.FirstOrDefault(m => m.Value.Contains(method)).Key;
+                        var covariantReturnMethod = covariantReturnMethodMap
+                            .FirstOrDefault(m => m.InterfaceDeclarations.Contains(method))
+                            .CovariantReturnMethod;
+
                         DefineExplicitMethod(method, targetType, typeDesc, covariantReturnMethod);
                     }
                 }
             }
 
             internal static void DefineClassProxyMethods(Type serviceType, Type implType, Type[] additionalInterfaces, TypeDesc typeDesc)
             {
+                var covariantReturnMethodMap = implType.GetCovariantReturnMethods();
                 foreach (var method in serviceType.GetTypeInfo().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(x => !x.IsPropertyBinding()))
                 {
+                    if (covariantReturnMethodMap.Any(m => m.OverridenMethod.EqualAnyBaseDefinitionTo(method)))
+                        continue;
+
                     if (method.IsVisibleAndVirtual() && !_ignores.Contains(method.Name))
                         DefineClassMethod(method, implType, typeDesc);
                 }
@@ -461,7 +448,7 @@ internal static MethodBuilder DefineExplicitMethod(MethodInfo method, Type implT
                 return methodBuilder;
             }
 
-            internal static MethodBuilder DefineClassMethod(MethodInfo method, Type implType, TypeDesc typeDesc)
+            internal static MethodBuilder DefineClassMethod(MethodInfo method, Type implType, TypeDesc typeDesc, bool isNewSlot = false)
             {
                 var attributes = OverrideMethodAttributes;
 
@@ -480,15 +467,22 @@ internal static MethodBuilder DefineClassMethod(MethodInfo method, Type implType
                     attributes |= MethodAttributes.FamORAssem;
                 }
 
+                if (isNewSlot)
+                {
+                    attributes |= MethodAttributes.NewSlot;
+                }
+
                 var methodBuilder = DefineMethod(method, method.Name, attributes, implType, typeDesc);
                 return methodBuilder;
             }
-            
+
             // NOTE: when a covariant return method is handling:
             // For class proxy: We just define the covariant return methods in the implementation type like normal methods, the CLR will handle the propagation. (in this case covariantReturnMethod is null)
             // For interface proxy: We need to use the covariant return methods as the interface methods' implementation. (in this case covariantReturnMethod is not null)
             private static MethodBuilder DefineMethod(MethodInfo method, string name, MethodAttributes attributes, Type implType, TypeDesc typeDesc, MethodInfo covariantReturnMethod = null)
             {
+                var methodBuilder = typeDesc.Builder.DefineMethod(name, attributes, method.CallingConvention, method.ReturnType, method.GetParameterTypes());
+
                 var implementationMethod = covariantReturnMethod ?? implType.GetTypeInfo().GetMethodBySignature(method);
                 if (implementationMethod == null)
                 {
@@ -520,20 +514,6 @@ private static MethodBuilder DefineMethod(MethodInfo method, string name, Method
                     }
                 }
 
-                // NOTE: both covariant return method and its corresponding overridden method should be defined with NewSlot attribute.
-                if (method.IsPreserveBaseOverride(true))
-                {
-                    // PreserveBaseOverridesAttribute is used to indicate that the method is a covariant return method.
-                    attributes |= MethodAttributes.NewSlot;
-                }
-                else if (implementationMethod.Attributes.HasFlag(MethodAttributes.NewSlot) && implementationMethod.IsOverriden())
-                {
-                    // an overridden method with NewSlot attribute is a method overriden by a covariant return method.
-                    attributes |= MethodAttributes.NewSlot;
-                }
-
-                var methodBuilder = typeDesc.Builder.DefineMethod(name, attributes, method.CallingConvention, method.ReturnType, method.GetParameterTypes());
-
                 GenericParameterUtils.DefineGenericParameter(method, methodBuilder);
 
                 //define method attributes
@@ -542,6 +522,9 @@ private static MethodBuilder DefineMethod(MethodInfo method, string name, Method
                 //inherit targetMethod's attribute
                 foreach (var customAttributeData in method.CustomAttributes)
                 {
+                    if (customAttributeData.AttributeType == AspectCore.Extensions.MethodInfoExtensions.PreserveBaseOverridesAttribute)
+                        continue;
+
                     methodBuilder.SetCustomAttribute(CustomAttributeBuilderUtils.DefineCustomAttribute(customAttributeData));
                 }
 
@@ -777,13 +760,13 @@ private class PropertyBuilderUtils
         {
             public static void DefineInterfaceProxyProperties(Type interfaceType, Type implType, Type[] additionalInterfaces, TypeDesc typeDesc)
             {
-                var covariantReturnMethodMap = GetCovariantReturnMethodMap(implType);
+                var covariantReturnMethodMap = implType.GetCovariantReturnMethods();
 
                 foreach (var property in interfaceType.GetTypeInfo().DeclaredProperties)
                 {
                     var builder = DefineInterfaceProxyProperty(property, property.Name, implType, typeDesc);
                     var covariantReturnGetter = property.CanRead
-                        ? covariantReturnMethodMap.FirstOrDefault(m => m.Value.Contains(property.GetMethod)).Key
+                        ? covariantReturnMethodMap.FirstOrDefault(m => m.InterfaceDeclarations.Contains(property.GetMethod)).CovariantReturnMethod
                         : null;
                     DefineInterfacePropertyMethod(builder, property, implType, typeDesc, covariantReturnGetter);
                 }
@@ -793,7 +776,7 @@ public static void DefineInterfaceProxyProperties(Type interfaceType, Type implT
                     {
                         var builder = DefineInterfaceProxyProperty(property, property.GetDisplayName(), implType, typeDesc);
                         var covariantReturnGetter = property.CanRead
-                            ? covariantReturnMethodMap.FirstOrDefault(m => m.Value.Contains(property.GetMethod)).Key
+                            ? covariantReturnMethodMap.FirstOrDefault(m => m.InterfaceDeclarations.Contains(property.GetMethod)).CovariantReturnMethod
                             : null;
                         DefineExplicitPropertyMethod(builder, property, implType, typeDesc, covariantReturnGetter);
                     }
@@ -802,12 +785,31 @@ public static void DefineInterfaceProxyProperties(Type interfaceType, Type implT
 
             internal static void DefineClassProxyProperties(Type serviceType, Type implType, Type[] additionalInterfaces, TypeDesc typeDesc)
             {
+                var covariantReturnMethodMap = implType.GetCovariantReturnMethods();
+
                 foreach (var property in serviceType.GetTypeInfo().GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
                 {
+                    var isNewSlot = false;
+
+                    if (property.CanRead)
+                    {
+                        // skip if the property is overridden by a covariant return method
+                        if (covariantReturnMethodMap.Any(m => m.CovariantReturnMethod.EqualAnyBaseDefinitionTo(property.GetMethod)
+                                                              && m.OverridenMethod.ReturnType == property.PropertyType))
+                            continue;
+
+                        if (covariantReturnMethodMap.Any(m => m.CovariantReturnMethod.EqualAnyBaseDefinitionTo(property.GetMethod)
+                                                              && m.CovariantReturnMethod.ReturnType == property.PropertyType))
+                        {
+                            // this property's getter is a covariant return method.
+                            isNewSlot = true;
+                        }
+                    }
+
                     if (property.IsVisibleAndVirtual())
                     {
                         var builder = DefineInterfaceProxyProperty(property, property.Name, implType, typeDesc);
-                        DefineClassPropertyMethod(builder, property, implType, typeDesc);
+                        DefineClassPropertyMethod(builder, property, implType, typeDesc, isNewSlot);
                     }
                 }
                 foreach (var item in additionalInterfaces)
@@ -820,11 +822,11 @@ internal static void DefineClassProxyProperties(Type serviceType, Type implType,
                 }
             }
 
-            private static void DefineClassPropertyMethod(PropertyBuilder propertyBuilder, PropertyInfo property, Type implType, TypeDesc typeDesc)
+            private static void DefineClassPropertyMethod(PropertyBuilder propertyBuilder, PropertyInfo property, Type implType, TypeDesc typeDesc, bool isNewSlot = false)
             {
                 if (property.CanRead)
                 {
-                    var method = MethodBuilderUtils.DefineClassMethod(property.GetMethod, implType, typeDesc);
+                    var method = MethodBuilderUtils.DefineClassMethod(property.GetMethod, implType, typeDesc, isNewSlot);
                     propertyBuilder.SetGetMethod(method);
                 }
                 if (property.CanWrite)
@@ -1133,13 +1135,13 @@ internal static void DefineGenericParameter(Type targetType, TypeBuilder typeBui
                 }
             }
 
-            internal static void DefineGenericParameter(MethodInfo tergetMethod, MethodBuilder methodBuilder)
+            internal static void DefineGenericParameter(MethodInfo targetMethod, MethodBuilder methodBuilder)
             {
-                if (!tergetMethod.IsGenericMethod)
+                if (!targetMethod.IsGenericMethod)
                 {
                     return;
                 }
-                var genericArguments = tergetMethod.GetGenericArguments().Select(t => t.GetTypeInfo()).ToArray();
+                var genericArguments = targetMethod.GetGenericArguments().Select(t => t.GetTypeInfo()).ToArray();
                 var genericArgumentsBuilders = methodBuilder.DefineGenericParameters(genericArguments.Select(a => a.Name).ToArray());
                 for (var index = 0; index < genericArguments.Length; index++)
                 {