Change CecilSymbolHelper to instance class

src/coverlet.collector/DataCollection/CoverageManager.cs

@@ -23,7 +23,7 @@ internal class CoverageManager
         public IReporter[] Reporters { get; }
 
         public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, TestPlatformLogger logger, ICoverageWrapper coverageWrapper,
-                               IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator)
+                               IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper)
             : this(settings,
             settings.ReportFormats.Select(format =>
             {
@@ -39,19 +39,19 @@ public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace,
                 }
             }).Where(r => r != null).ToArray(),
             new CoverletLogger(eqtTrace, logger),
-            coverageWrapper, instrumentationHelper, fileSystem, sourceRootTranslator)
+            coverageWrapper, instrumentationHelper, fileSystem, sourceRootTranslator, cecilSymbolHelper)
         {
         }
 
         public CoverageManager(CoverletSettings settings, IReporter[] reporters, ILogger logger, ICoverageWrapper coverageWrapper,
-                               IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator)
+                               IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper)
         {
             // Store input vars
             Reporters = reporters;
             _coverageWrapper = coverageWrapper;
 
             // Coverage object
-            _coverage = _coverageWrapper.CreateCoverage(settings, logger, instrumentationHelper, fileSystem, sourceRootTranslator);
+            _coverage = _coverageWrapper.CreateCoverage(settings, logger, instrumentationHelper, fileSystem, sourceRootTranslator, cecilSymbolHelper);
         }
 
         /// <summary>

src/coverlet.collector/DataCollection/CoverageWrapper.cs

@@ -15,7 +15,7 @@ internal class CoverageWrapper : ICoverageWrapper
         /// <param name="settings">Coverlet settings</param>
         /// <param name="coverletLogger">Coverlet logger</param>
         /// <returns>Coverage object</returns>
-        public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator)
+        public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper)
         {
             return new Coverage(
                 settings.TestModule,
@@ -31,7 +31,8 @@ public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger
                 coverletLogger,
                 instrumentationHelper,
                 fileSystem,
-                sourceRootTranslator);
+                sourceRootTranslator,
+                cecilSymbolHelper);
         }
 
         /// <summary>

src/coverlet.collector/DataCollection/CoverletCoverageCollector.cs

@@ -7,6 +7,7 @@
 using Coverlet.Collector.Utilities.Interfaces;
 using Coverlet.Core.Abstractions;
 using Coverlet.Core.Helpers;
+using Coverlet.Core.Symbols;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestPlatform.ObjectModel.DataCollection;
 
@@ -133,7 +134,7 @@ private void OnSessionStart(object sender, SessionStartEventArgs sessionStartEve
                 // Get coverage and attachment managers
                 _coverageManager = new CoverageManager(coverletSettings, _eqtTrace, _logger, _coverageWrapper,
                                                         _serviceProvider.GetRequiredService<IInstrumentationHelper>(), _serviceProvider.GetRequiredService<IFileSystem>(),
-                                                        _serviceProvider.GetRequiredService<ISourceRootTranslator>());
+                                                        _serviceProvider.GetRequiredService<ISourceRootTranslator>(), _serviceProvider.GetRequiredService<ICecilSymbolHelper>());
 
                 // Instrument modules
                 _coverageManager.InstrumentModules();
@@ -227,6 +228,7 @@ private static IServiceCollection GetDefaultServiceCollection(TestPlatformEqtTra
             serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
             // We cache resolutions
             serviceCollection.AddSingleton<ISourceRootTranslator, SourceRootTranslator>(serviceProvider => new SourceRootTranslator(testModule, serviceProvider.GetRequiredService<ILogger>(), serviceProvider.GetRequiredService<IFileSystem>()));
+            serviceCollection.AddSingleton<ICecilSymbolHelper, CecilSymbolHelper>();
             return serviceCollection;
         }
     }

src/coverlet.collector/Utilities/Interfaces/ICoverageWrapper.cs

@@ -14,12 +14,13 @@ internal interface ICoverageWrapper
         /// Creates a coverage object from given coverlet settings
         /// </summary>
         /// <param name="settings">Coverlet settings</param>
-        /// <param name="coverletLogger">Coverlet logger</param>
+        /// <param name="logger">Coverlet logger</param>
         /// <param name="instrumentationHelper">Coverlet instrumentationHelper</param>
         /// <param name="fileSystem">Coverlet fileSystem</param>
         /// <param name="sourceRootTranslator">Coverlet sourceRootTranslator</param>
+        /// <param name="cecilSymbolHelper"></param>
         /// <returns>Coverage object</returns>
-        Coverage CreateCoverage(CoverletSettings settings, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator);
+        Coverage CreateCoverage(CoverletSettings settings, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper);
 
         /// <summary>
         /// Gets the coverage result from provided coverage object

src/coverlet.console/Program.cs

@@ -12,6 +12,7 @@
 using Coverlet.Core.Enums;
 using Coverlet.Core.Helpers;
 using Coverlet.Core.Reporters;
+using Coverlet.Core.Symbols;
 using McMaster.Extensions.CommandLineUtils;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -29,12 +30,12 @@ static int Main(string[] args)
             // We need to keep singleton/static semantics
             serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
             serviceCollection.AddSingleton<ISourceRootTranslator, SourceRootTranslator>(provider => new SourceRootTranslator(provider.GetRequiredService<ILogger>(), provider.GetRequiredService<IFileSystem>()));
+            serviceCollection.AddSingleton<ICecilSymbolHelper, CecilSymbolHelper>();
 
             ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
 
             var logger = (ConsoleLogger) serviceProvider.GetService<ILogger>();
             var fileSystem = serviceProvider.GetService<IFileSystem>();
-            var sourceTranslator = serviceProvider.GetService<ISourceRootTranslator>();
 
             var app = new CommandLineApplication();
             app.Name = "coverlet";
@@ -86,9 +87,10 @@ static int Main(string[] args)
                     mergeWith.Value(),
                     useSourceLink.HasValue(),
                     logger,
-                    serviceProvider.GetService<IInstrumentationHelper>(),
+                    serviceProvider.GetRequiredService<IInstrumentationHelper>(),
                     fileSystem,
-                    sourceTranslator);
+                    serviceProvider.GetRequiredService<ISourceRootTranslator>(),
+                    serviceProvider.GetRequiredService<ICecilSymbolHelper>());
                 coverage.PrepareModules();
 
                 Process process = new Process();

src/coverlet.core/Abstractions/ICecilSymbolHelper.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using Coverlet.Core.Symbols;
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace Coverlet.Core.Abstractions
+{
+    internal interface ICecilSymbolHelper
+    {
+        IReadOnlyList<BranchPoint> GetBranchPoints(MethodDefinition methodDefinition);
+        bool SkipNotCoverableInstruction(MethodDefinition methodDefinition, Instruction instruction);
+    }
+}

src/coverlet.core/Coverage.cs

@@ -27,6 +27,7 @@ internal class Coverage
         private IInstrumentationHelper _instrumentationHelper;
         private IFileSystem _fileSystem;
         private ISourceRootTranslator _sourceRootTranslator;
+        private ICecilSymbolHelper _cecilSymbolHelper;
         private List<InstrumenterResult> _results;
 
         public string Identifier
@@ -47,7 +48,8 @@ public Coverage(string module,
             ILogger logger,
             IInstrumentationHelper instrumentationHelper,
             IFileSystem fileSystem,
-            ISourceRootTranslator sourceRootTranslator)
+            ISourceRootTranslator sourceRootTranslator,
+            ICecilSymbolHelper cecilSymbolHelper)
         {
             _module = module;
             _includeFilters = includeFilters;
@@ -63,6 +65,7 @@ public Coverage(string module,
             _instrumentationHelper = instrumentationHelper;
             _fileSystem = fileSystem;
             _sourceRootTranslator = sourceRootTranslator;
+            _cecilSymbolHelper = cecilSymbolHelper;
 
             _identifier = Guid.NewGuid().ToString();
             _results = new List<InstrumenterResult>();
@@ -100,7 +103,7 @@ public CoveragePrepareResult PrepareModules()
                     continue;
                 }
 
-                var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, _excludedSourceFiles, _excludeAttributes, _singleHit, _logger, _instrumentationHelper, _fileSystem, _sourceRootTranslator);
+                var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, _excludedSourceFiles, _excludeAttributes, _singleHit, _logger, _instrumentationHelper, _fileSystem, _sourceRootTranslator, _cecilSymbolHelper);
 
                 if (instrumenter.CanInstrument())
                 {

src/coverlet.core/Instrumentation/Instrumenter.cs

@@ -30,6 +30,7 @@ internal class Instrumenter
         private readonly IInstrumentationHelper _instrumentationHelper;
         private readonly IFileSystem _fileSystem;
         private readonly ISourceRootTranslator _sourceRootTranslator;
+        private readonly ICecilSymbolHelper _cecilSymbolHelper;
         private InstrumenterResult _result;
         private FieldDefinition _customTrackerHitsArray;
         private FieldDefinition _customTrackerHitsFilePath;
@@ -57,7 +58,8 @@ public Instrumenter(
             ILogger logger,
             IInstrumentationHelper instrumentationHelper,
             IFileSystem fileSystem,
-            ISourceRootTranslator sourceRootTranslator)
+            ISourceRootTranslator sourceRootTranslator,
+            ICecilSymbolHelper cecilSymbolHelper)
         {
             _module = module;
             _identifier = identifier;
@@ -71,6 +73,7 @@ public Instrumenter(
             _instrumentationHelper = instrumentationHelper;
             _fileSystem = fileSystem;
             _sourceRootTranslator = sourceRootTranslator;
+            _cecilSymbolHelper = cecilSymbolHelper;
         }
 
         public bool CanInstrument()
@@ -447,7 +450,7 @@ private void InstrumentIL(MethodDefinition method)
             var index = 0;
             var count = processor.Body.Instructions.Count;
 
-            var branchPoints = CecilSymbolHelper.GetBranchPoints(method);
+            var branchPoints = _cecilSymbolHelper.GetBranchPoints(method);
 
             for (int n = 0; n < count; n++)
             {
@@ -456,7 +459,7 @@ private void InstrumentIL(MethodDefinition method)
                 var targetedBranchPoints = branchPoints.Where(p => p.EndOffset == instruction.Offset);
 
                 // Check if the instruction is coverable
-                if (CecilSymbolHelper.SkipNotCoverableInstruction(method, instruction))
+                if (_cecilSymbolHelper.SkipNotCoverableInstruction(method, instruction))
                 {
                     index++;
                     continue;

src/coverlet.core/Symbols/CecilSymbolHelper.cs

@@ -7,7 +7,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
-
+using Coverlet.Core.Abstractions;
 using Coverlet.Core.Extensions;
 
 using Mono.Cecil;
@@ -16,16 +16,11 @@
 
 namespace Coverlet.Core.Symbols
 {
-    internal static class CecilSymbolHelper
+    internal class CecilSymbolHelper : ICecilSymbolHelper
     {
         private const int StepOverLineCode = 0xFEEFEE;
-        private static ConcurrentDictionary<string, int[]> CompilerGeneratedBranchesToExclude = null;
-
-        static CecilSymbolHelper()
-        {
-            // Create single instance, we cannot collide because we use full method name as key
-            CompilerGeneratedBranchesToExclude = new ConcurrentDictionary<string, int[]>();
-        }
+        // Create single instance, we cannot collide because we use full method name as key
+        private readonly ConcurrentDictionary<string, int[]> _compilerGeneratedBranchesToExclude = new ConcurrentDictionary<string, int[]>();
 
         // In case of nested compiler generated classes, only the root one presents the CompilerGenerated attribute.
         // So let's search up to the outermost declaring type to find the attribute
@@ -265,9 +260,9 @@ private static bool SkipGeneratedBranchForExceptionRethrown(List<Instruction> in
                     instructions[branchIndex + 3].OpCode == OpCodes.Throw;
         }
 
-        private static bool SkipGeneratedBranchesForExceptionHandlers(MethodDefinition methodDefinition, Instruction instruction, List<Instruction> bodyInstructions)
+        private bool SkipGeneratedBranchesForExceptionHandlers(MethodDefinition methodDefinition, Instruction instruction, List<Instruction> bodyInstructions)
         {
-            if (!CompilerGeneratedBranchesToExclude.ContainsKey(methodDefinition.FullName))
+            if (!_compilerGeneratedBranchesToExclude.ContainsKey(methodDefinition.FullName))
             {
                 /*
                   This method is used to parse compiler generated code inside async state machine and find branches generated for exception catch blocks
@@ -393,13 +388,13 @@ private static bool SkipGeneratedBranchesForExceptionHandlers(MethodDefinition m
                     }
                 }
 
-                CompilerGeneratedBranchesToExclude.TryAdd(methodDefinition.FullName, detectedBranches.ToArray());
+                _compilerGeneratedBranchesToExclude.TryAdd(methodDefinition.FullName, detectedBranches.ToArray());
             }
 
-            return CompilerGeneratedBranchesToExclude[methodDefinition.FullName].Contains(instruction.Offset);
+            return _compilerGeneratedBranchesToExclude[methodDefinition.FullName].Contains(instruction.Offset);
         }
 
-        public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinition)
+        public IReadOnlyList<BranchPoint> GetBranchPoints(MethodDefinition methodDefinition)
         {
             var list = new List<BranchPoint>();
             if (methodDefinition is null)
@@ -664,7 +659,7 @@ await ...
            IL_00eb: br.s IL_00ed
            ...
        */
-        internal static bool SkipNotCoverableInstruction(MethodDefinition methodDefinition, Instruction instruction)
+        public bool SkipNotCoverableInstruction(MethodDefinition methodDefinition, Instruction instruction)
         {
             if (!IsMoveNextInsideAsyncStateMachine(methodDefinition))
             {

src/coverlet.msbuild.tasks/InstrumentationTask.cs

@@ -5,6 +5,7 @@
 using Coverlet.Core;
 using Coverlet.Core.Abstractions;
 using Coverlet.Core.Helpers;
+using Coverlet.Core.Symbols;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -131,6 +132,7 @@ public override bool Execute()
             serviceCollection.AddSingleton<ISourceRootTranslator, SourceRootTranslator>(serviceProvider => new SourceRootTranslator(_path, serviceProvider.GetRequiredService<ILogger>(), serviceProvider.GetRequiredService<IFileSystem>()));
             // We need to keep singleton/static semantics
             serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
+            serviceCollection.AddSingleton<ICecilSymbolHelper, CecilSymbolHelper>();
 
             ServiceProvider = serviceCollection.BuildServiceProvider();
 
@@ -156,7 +158,8 @@ public override bool Execute()
                     _logger,
                     ServiceProvider.GetService<IInstrumentationHelper>(),
                     fileSystem,
-                    ServiceProvider.GetService<ISourceRootTranslator>());
+                    ServiceProvider.GetService<ISourceRootTranslator>(),
+                    ServiceProvider.GetService<ICecilSymbolHelper>());
 
                 CoveragePrepareResult prepareResult = coverage.PrepareModules();
                 InstrumenterState = new TaskItem(System.IO.Path.GetTempFileName());