#762: Improved handling of generic classes in DynamicCodeCoverage files (generated by dotnet-coverage)

Author: danielpalme

src/ReportGenerator.Core.Test/Parser/DynamicCodeCoverageClassNameParserTest.cs

@@ -10,80 +10,66 @@ public class DynamicCodeCoverageClassNameParserTest
             "AbstractClass",
             "Test",
             "AbstractClass",
-            "AbstractClass",
-            null,
             "Test.AbstractClass",
             true)]
         [InlineData(
             "TestClass.NestedClass",
             "Test",
             "TestClass",
-            "TestClass",
-            null,
             "Test.TestClass",
             true)]
         [InlineData(
             "AsyncClass.<SendAsync>d__0",
             "Test",
             "AsyncClass",
-            "AsyncClass",
-            null,
             "Test.AsyncClass",
             true)]
         [InlineData(
             "GenericAsyncClass<T>",
             "Test",
             "GenericAsyncClass",
-            "GenericAsyncClass<T>",
-            "<T>",
-            "Test.GenericAsyncClass<T>",
+            "Test.GenericAsyncClass",
             true)]
         [InlineData(
             "ClassWithLocalFunctions.MyNestedClass<T1, T2>",
             "Test",
             "ClassWithLocalFunctions",
-            "ClassWithLocalFunctions",
-            null,
             "Test.ClassWithLocalFunctions",
             true)]
         [InlineData(
             "GenericAsyncClass.<MyAsyncMethod>d__1<T>",
             "Test",
             "GenericAsyncClass",
-            "GenericAsyncClass<T>",
-            "<T>",
-            "Test.GenericAsyncClass<T>",
+            "Test.GenericAsyncClass",
             true)]
         [InlineData(
             "Program.<CallAsyncMethod>d__1",
             "Test",
             "Program",
-            "Program",
-            null,
             "Test.Program",
             true)]
         [InlineData(
             "AutoMapperExtensions.<>c__1<TResult>",
             "Test",
             "AutoMapperExtensions",
-            "AutoMapperExtensions",
-            null,
             "Test.AutoMapperExtensions",
             true)]
+        [InlineData(
+            "TestClass.<GenericAsyncMethod>d__4<T>",
+            "Test",
+            "TestClass",
+            "Test.TestClass",
+            true)]
         public void ParseClassName(
             string rawName,
             string @namespace,
             string expectedName,
-            string expectedDisplayName,
-            string expectedGenericType,
             string expectedFullName,
             bool expectedInclude)
         {
             var result = DynamicCodeCoverageClassNameParser.ParseClassName(rawName, @namespace);
 
             Assert.Equal(expectedName, result.Name);
-            Assert.Equal(expectedDisplayName, result.DisplayName);
-            Assert.Equal(expectedGenericType, result.GenericType);
             Assert.Equal(expectedFullName, result.FullName);
             Assert.Equal(expectedInclude, result.Include);
         }

src/ReportGenerator.Core/Parser/DynamicCodeCoverageClassNameParser.cs

@@ -11,7 +11,7 @@ internal static class DynamicCodeCoverageClassNameParser
         /// <summary>
         /// Regex to clean class names from compiler generated parts.
         /// </summary>
-        private static readonly Regex CleanupRegex = new Regex("\\.<>\\w_?_?\\w*\\d*<.*>|\\.<.*>\\w_?_?\\w*\\d*", RegexOptions.Compiled);
+        private static readonly Regex CleanupRegex = new Regex("<.*?>", RegexOptions.Compiled);
 
         /// <summary>
         /// Regex to analyze if a class name represents a generic class.
@@ -39,36 +39,10 @@ public static DynamicCodeCoverageClassNameParserResult ParseClassName(
 
             if (nestedClassSeparatorIndex > -1)
             {
-                string className = cleanedClassName.Substring(0, nestedClassSeparatorIndex);
-                return new DynamicCodeCoverageClassNameParserResult(namespaceOfClass, className, className, IncludeClass(className));
+                cleanedClassName = cleanedClassName.Substring(0, nestedClassSeparatorIndex);
             }
 
-            if (cleanedClassName.Contains("<"))
-            {
-                var match = GenericClassRegex.Match(cleanedClassName);
-
-                if (match.Success)
-                {
-                    return new DynamicCodeCoverageClassNameParserResult(
-                        namespaceOfClass,
-                        match.Groups["ClassName"].Value,
-                        match.Groups["ClassName"].Value + match.Groups["GenericTypes"].Value,
-                        IncludeClass(match.Groups["ClassName"].Value))
-                    {
-                        GenericType = match.Groups["GenericTypes"].Value
-                    };
-                }
-                else
-                {
-                    return new DynamicCodeCoverageClassNameParserResult(
-                        namespaceOfClass,
-                        cleanedClassName,
-                        cleanedClassName,
-                        IncludeClass(cleanedClassName));
-                }
-            }
-
-            return new DynamicCodeCoverageClassNameParserResult(namespaceOfClass, cleanedClassName, cleanedClassName, IncludeClass(cleanedClassName));
+            return new DynamicCodeCoverageClassNameParserResult(namespaceOfClass, cleanedClassName, IncludeClass(rawName));
         }
 
         /// <summary>
@@ -78,8 +52,7 @@ public static DynamicCodeCoverageClassNameParserResult ParseClassName(
         /// <returns>True if the class should be included; otherwise, false.</returns>
         private static bool IncludeClass(string name)
         {
-            return !name.Contains("<>")
-                && !name.StartsWith("$", StringComparison.OrdinalIgnoreCase);
+            return !name.StartsWith("$", StringComparison.OrdinalIgnoreCase);
         }
     }
 }

src/ReportGenerator.Core/Parser/DynamicCodeCoverageClassNameParserResult.cs

@@ -10,17 +10,14 @@ internal class DynamicCodeCoverageClassNameParserResult
         /// </summary>
         /// <param name="namespaceOfClass">The namespace.</param>
         /// <param name="name">The name.</param>
-        /// <param name="displayName">The display name.</param>
         /// <param name="include">Indicates whether the class should be included in the report.</param>
         public DynamicCodeCoverageClassNameParserResult(
             string namespaceOfClass,
             string name,
-            string displayName,
             bool include)
         {
             this.Namespace = namespaceOfClass;
             this.Name = name;
-            this.DisplayName = displayName;
             this.Include = include;
         }
 
@@ -34,20 +31,10 @@ public DynamicCodeCoverageClassNameParserResult(
         /// </summary>
         public string Name { get; }
 
-        /// <summary>
-        /// Gets the display name.
-        /// </summary>
-        public string DisplayName { get; }
-
-        /// <summary>
-        /// Gets or sets the generic type.
-        /// </summary>
-        public string GenericType { get; set; }
-
         /// <summary>
         /// Gets the full name.
         /// </summary>
-        public string FullName => this.Namespace == null ? this.DisplayName : $"{this.Namespace}.{this.DisplayName}";
+        public string FullName => this.Namespace == null ? this.Name : $"{this.Namespace}.{this.Name}";
 
         /// <summary>
         /// Gets a value indicating whether the class should be included in the report.
@@ -57,7 +44,7 @@ public DynamicCodeCoverageClassNameParserResult(
         /// <inheritdoc />
         public override string ToString()
         {
-            return this.DisplayName;
+            return this.Name;
         }
 
         /// <inheritdoc />
@@ -71,12 +58,11 @@ public override bool Equals(object obj)
             {
                 var classNameParserResult = (DynamicCodeCoverageClassNameParserResult)obj;
                 return string.Equals(classNameParserResult.Name, this.Name)
-                    && string.Equals(classNameParserResult.DisplayName, this.DisplayName)
                     && string.Equals(classNameParserResult.Namespace, this.Namespace);
             }
         }
 
         /// <inheritdoc />
-        public override int GetHashCode() => this.Name.GetHashCode() + this.DisplayName.GetHashCode() + (this.Namespace?.GetHashCode()).GetValueOrDefault();
+        public override int GetHashCode() => this.Name.GetHashCode() + (this.Namespace?.GetHashCode()).GetValueOrDefault();
     }
 }

src/Testprojects/CSharp/Project_DotNetCore/Test/AutoMapperExtensions.cs

@@ -5,12 +5,12 @@ namespace Test
 {
     public static class AutoMapperExtensions
     {
-        public static TResult MergeInto<TResult>(this IMapper mapper, object item)
+        public static TResult MergeIntoSingle<TResult>(this IMapper mapper, object item)
         {
             return mapper.Map<TResult>(item);
         }
 
-        public static TResult MergeInto<TResult>(this IMapper mapper, params object?[] objects)
+        public static TResult MergeIntoSeveral<TResult>(this IMapper mapper, params object?[] objects)
         {
             var res = mapper.Map<TResult>(objects.First());
             return objects.Skip(1).Where(x => x is not null).Aggregate(res, (r, obj) => mapper.Map(obj, r));

src/Testprojects/CSharp/Project_DotNetCore/Test/GenericAsyncClass.cs

@@ -10,12 +10,59 @@ public void DoWork()
             Console.WriteLine("BaseService DoWork");
         }
 
+        public void MyMethod()
+        {
+        }
+
         public async Task MyAsyncMethod()
         {
         }
+
+        public async Task<T> MyAsyncGenericMethod<T1>(T1 something)
+        {
+            return default;
+        }
+
         public async Task<T> MyAsyncMethod(T something)
         {
             return something;
         }
+
+        public class InnerGenericClass<U>
+        {
+            public void MyNestedMethod()
+            {
+            }
+
+            public async Task MyNestedAsyncMethod()
+            {
+            }
+
+            public async Task<T> MyNestedAsyncGenericMethod<U1>(U1 something)
+            {
+                return default;
+            }
+
+            public async Task<U> MyNestedAsyncMethod(U something)
+            {
+                return something;
+            }
+        }
+
+        public class InnerNonGenericClass
+        {
+            public void MyNestedMethod()
+            {
+            }
+
+            public async Task MyNestedAsyncMethod()
+            {
+            }
+
+            public async Task<T> MyNestedAsyncGenericMethod<U1>(U1 something)
+            {
+                return default;
+            }
+        }
     }
 }

src/Testprojects/CSharp/Project_DotNetCore/Test/TestClass.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Test
 {
@@ -46,6 +47,17 @@ public void MethodWithLambda()
             var chars2 = "abc".Where(lambda).ToArray();
         }
 
+
+        public void GenericMethod<T>(T messageObject)
+        {
+
+        }
+
+        public async Task GenericAsyncMethod<T>(T messageObject)
+        {
+
+        }
+
         public class NestedClass
         {
             public void SampleFunction()