made dispose check work for generic types

Author: daveMueller

Documentation/Changelog.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Fixed
+-Incorrect coverage for methods returning IAsyncEnumerable in generic classes [#1383](https://github.com/coverlet-coverage/coverlet/issues/1383)
+
 ### Breaking changes
 - New parameter `ExcludeAssembliesWithoutSources` to control automatic assembly exclusion [1164](https://github.com/coverlet-coverage/coverlet/issues/1164). The parameter `InstrumentModulesWithoutLocalSources` has been removed. since it can be handled by setting `ExcludeAssembliesWithoutSources` to `None`.
 - The default heuristics for determining whether to instrument an assembly has been changed. In previous versions any missing source file was taken as a signal that it was a third-party project that shouldn't be instrumented, with exceptions for some common file name patterns for source generators. Now only assemblies where no source files at all can be found are excluded from instrumentation, and the code for detecting source generator files have been removed. To get back to the behaviour that at least one missing file is sufficient to exclude an assembly, set `ExcludeAssembliesWithoutSources` to `MissingAny`, or use assembly exclusion filters for more fine-grained control.

src/coverlet.core/Symbols/CecilSymbolHelper.cs

@@ -877,8 +877,10 @@ static bool DisposeCheck(List<Instruction> instructions, Instruction instruction
 
                 if (currentIndex >= 2 &&
                     instructions[currentIndex - 1].OpCode == OpCodes.Ldfld &&
-                    instructions[currentIndex - 1].Operand is FieldDefinition field &&
-                    IsCompilerGenerated(field) && field.FullName.EndsWith("__disposeMode") &&
+                    (
+                        (instructions[currentIndex - 1].Operand is FieldDefinition field && IsCompilerGenerated(field) && field.FullName.EndsWith("__disposeMode")) ||
+                        (instructions[currentIndex - 1].Operand is FieldReference fieldRef && IsCompilerGenerated(fieldRef.Resolve()) && fieldRef.FullName.EndsWith("__disposeMode"))
+                    ) &&
                     (instructions[currentIndex - 2].OpCode == OpCodes.Ldarg ||
                      instructions[currentIndex - 2].OpCode == OpCodes.Ldarg_0))
                 {

test/coverlet.core.tests/Coverage/CoverageTests.GenericAsyncIterator.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Toni Solarin-Sodara
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using Coverlet.Core.Samples.Tests;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void GenericAsyncIterator()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                FunctionExecutor.Run(async (string[] pathSerialize) =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<GenericAsyncIterator<int>>(instance =>
+                    {
+                        List<int> res = ((Task<List<int>>)instance.Issue1383()).GetAwaiter().GetResult();
+
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize[0]);
+                    return 0;
+                }, new string[] { path });
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                    .Document("Instrumentation.GenericAsyncIterator.cs")
+                    .AssertLinesCovered(BuildConfiguration.Debug, (13, 1), (14, 1), (20, 1), (21, 1), (22, 1))
+                    .ExpectedTotalNumberOfBranches(BuildConfiguration.Debug, 0);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}

test/coverlet.core.tests/Coverage/InstrumenterHelper.cs

@@ -101,7 +101,7 @@ public static async Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
                 IncludeFilters = (includeFilter is null ? defaultFilters(fileName) : includeFilter(fileName)).Concat(
                 new string[]
                 {
-                    $"[{Path.GetFileNameWithoutExtension(fileName)}*]{typeof(T).FullName}*"
+                    $"[{Path.GetFileNameWithoutExtension(fileName)}*]{GetTypeFullName<T>()}*"
                 }).ToArray(),
                 IncludeDirectories = Array.Empty<string>(),
                 ExcludeFilters = (excludeFilter is null ? defaultFilters(fileName) : excludeFilter(fileName)).Concat(new string[]
@@ -180,6 +180,17 @@ private static void SetTestContainer(string testModule = null, bool disableResto
                 return serviceCollection.BuildServiceProvider();
             });
         }
+
+        private static string GetTypeFullName<T>()
+        {
+            string name = typeof(T).FullName;
+            if (typeof(T).IsGenericType && name != null)
+            {
+                int index = name.IndexOf('`');
+                return index == -1 ? name : name[..index];
+            }
+            return name;
+        }
     }
 
     class CustomProcessExitHandler : IProcessExitHandler

test/coverlet.core.tests/Samples/Instrumentation.GenericAsyncIterator.cs

@@ -0,0 +1,25 @@
+// Remember to use full name because adding new using directives change line numbers
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Coverlet.Core.Samples.Tests
+{
+    public class GenericAsyncIterator<T>
+    {
+        public async Task<List<int>> Issue1383()
+        {
+            var sequence = await CreateSequenceAsync().ToListAsync();
+            return sequence;
+        }
+
+
+        public async IAsyncEnumerable<int> CreateSequenceAsync()
+        {
+            await Task.CompletedTask;
+            yield return 5;
+            yield return 2;
+        }
+    }
+}