Add skipautoprops feature

Documentation/GlobalTool.md

@@ -36,6 +36,7 @@ Options:
   --single-hit             Specifies whether to limit code coverage hit reporting to a single hit for each location.
   --merge-with             Path to existing coverage result to merge.
   --use-source-link        Specifies whether to use SourceLink URIs in place of file system paths.
+  --skipautoprops          Neither track nor record auto-implemented properties.
 ```
 
 NB. For a [multiple value] options you have to specify values multiple times i.e.

Documentation/MSBuildIntegration.md

@@ -157,6 +157,11 @@ Both `Exclude` and `Include` properties can be used together but `Exclude` takes
 
 You can also include coverage of the test assembly itself by setting `/p:IncludeTestAssembly` to `true`.
 
+### Skip auto-implemented properties  
+
+Neither track nor record auto-implemented properties.  
+Syntax:  `/p:SkipAutoProps=true`
+
 ### Note for Powershell / VSTS users
 To exclude or include multiple assemblies when using Powershell scripts or creating a .yaml file for a VSTS build ```%2c``` should be used as a separator. Msbuild will translate this symbol to ```,```.
 

Documentation/VSTestIntegration.md

@@ -79,6 +79,7 @@ These are a list of options that are supported by coverlet. These can be specifi
 |SingleHit       | Specifies whether to limit code coverage hit reporting to a single hit for each location.| 
 |UseSourceLink   | Specifies whether to use SourceLink URIs in place of file system paths.                  |
 |IncludeTestAssembly    | Include coverage of the test assembly.                  |
+|SkipAutoProps    | Neither track nor record auto-implemented properties.                  |
 
 How to specify these options via runsettings?
 ```
@@ -97,6 +98,7 @@ How to specify these options via runsettings?
           <SingleHit>false</SingleHit>
           <UseSourceLink>true</UseSourceLink>
           <IncludeTestAssembly>true</IncludeTestAssembly>
+          <SkipAutoProps>true</SkipAutoProps>
         </Configuration>
       </DataCollector>
     </DataCollectors>

README.md

@@ -164,6 +164,10 @@ to clarify expected behavior in our community.
 
 For more information, see the [.NET Foundation Code of Conduct](https://dotnetfoundation.org/code-of-conduct).
 
+## Credits
+
+Part of the code is based on work done by OpenCover team https://github.com/OpenCover
+
 ## License
 
 This project is licensed under the MIT license. See the [LICENSE](LICENSE) file for more info.  

src/coverlet.collector/DataCollection/CoverageWrapper.cs

@@ -27,7 +27,8 @@ public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger
                 IncludeTestAssembly = settings.IncludeTestAssembly,
                 SingleHit = settings.SingleHit,
                 MergeWith = settings.MergeWith,
-                UseSourceLink = settings.UseSourceLink
+                UseSourceLink = settings.UseSourceLink,
+                SkipAutoProps = settings.SkipAutoProps
             };
 
             return new Coverage(

src/coverlet.collector/DataCollection/CoverletSettings.cs

@@ -63,20 +63,26 @@ internal class CoverletSettings
         /// </summary>
         public bool IncludeTestAssembly { get; set; }
 
+        /// <summary>
+        /// Neither track nor record auto-implemented properties.
+        /// </summary>
+        public bool SkipAutoProps { get; set; }
+
         public override string ToString()
         {
             var builder = new StringBuilder();
 
-            builder.AppendFormat("TestModule: '{0}', ", this.TestModule);
-            builder.AppendFormat("IncludeFilters: '{0}', ", string.Join(",", this.IncludeFilters ?? Enumerable.Empty<string>()));
-            builder.AppendFormat("IncludeDirectories: '{0}', ", string.Join(",", this.IncludeDirectories ?? Enumerable.Empty<string>()));
-            builder.AppendFormat("ExcludeFilters: '{0}', ", string.Join(",", this.ExcludeFilters ?? Enumerable.Empty<string>()));
-            builder.AppendFormat("ExcludeSourceFiles: '{0}', ", string.Join(",", this.ExcludeSourceFiles ?? Enumerable.Empty<string>()));
-            builder.AppendFormat("ExcludeAttributes: '{0}', ", string.Join(",", this.ExcludeAttributes ?? Enumerable.Empty<string>()));
-            builder.AppendFormat("MergeWith: '{0}', ", this.MergeWith);
-            builder.AppendFormat("UseSourceLink: '{0}'", this.UseSourceLink);
-            builder.AppendFormat("SingleHit: '{0}'", this.SingleHit);
-            builder.AppendFormat("IncludeTestAssembly: '{0}'", this.IncludeTestAssembly);
+            builder.AppendFormat("TestModule: '{0}', ", TestModule);
+            builder.AppendFormat("IncludeFilters: '{0}', ", string.Join(",", IncludeFilters ?? Enumerable.Empty<string>()));
+            builder.AppendFormat("IncludeDirectories: '{0}', ", string.Join(",", IncludeDirectories ?? Enumerable.Empty<string>()));
+            builder.AppendFormat("ExcludeFilters: '{0}', ", string.Join(",", ExcludeFilters ?? Enumerable.Empty<string>()));
+            builder.AppendFormat("ExcludeSourceFiles: '{0}', ", string.Join(",", ExcludeSourceFiles ?? Enumerable.Empty<string>()));
+            builder.AppendFormat("ExcludeAttributes: '{0}', ", string.Join(",", ExcludeAttributes ?? Enumerable.Empty<string>()));
+            builder.AppendFormat("MergeWith: '{0}', ", MergeWith);
+            builder.AppendFormat("UseSourceLink: '{0}'", UseSourceLink);
+            builder.AppendFormat("SingleHit: '{0}'", SingleHit);
+            builder.AppendFormat("IncludeTestAssembly: '{0}'", IncludeTestAssembly);
+            builder.AppendFormat("SkipAutoProps: '{0}'", SkipAutoProps);
 
             return builder.ToString();
         }

src/coverlet.collector/DataCollection/CoverletSettingsParser.cs

@@ -29,23 +29,24 @@ public CoverletSettings Parse(XmlElement configurationElement, IEnumerable<strin
         {
             var coverletSettings = new CoverletSettings
             {
-                TestModule = this.ParseTestModule(testModules)
+                TestModule = ParseTestModule(testModules)
             };
 
             if (configurationElement != null)
             {
-                coverletSettings.IncludeFilters = this.ParseIncludeFilters(configurationElement);
-                coverletSettings.IncludeDirectories = this.ParseIncludeDirectories(configurationElement);
-                coverletSettings.ExcludeAttributes = this.ParseExcludeAttributes(configurationElement);
-                coverletSettings.ExcludeSourceFiles = this.ParseExcludeSourceFiles(configurationElement);
-                coverletSettings.MergeWith = this.ParseMergeWith(configurationElement);
-                coverletSettings.UseSourceLink = this.ParseUseSourceLink(configurationElement);
-                coverletSettings.SingleHit = this.ParseSingleHit(configurationElement);
-                coverletSettings.IncludeTestAssembly = this.ParseIncludeTestAssembly(configurationElement);
+                coverletSettings.IncludeFilters = ParseIncludeFilters(configurationElement);
+                coverletSettings.IncludeDirectories = ParseIncludeDirectories(configurationElement);
+                coverletSettings.ExcludeAttributes = ParseExcludeAttributes(configurationElement);
+                coverletSettings.ExcludeSourceFiles = ParseExcludeSourceFiles(configurationElement);
+                coverletSettings.MergeWith = ParseMergeWith(configurationElement);
+                coverletSettings.UseSourceLink = ParseUseSourceLink(configurationElement);
+                coverletSettings.SingleHit = ParseSingleHit(configurationElement);
+                coverletSettings.IncludeTestAssembly = ParseIncludeTestAssembly(configurationElement);
+                coverletSettings.SkipAutoProps = ParseSkipAutoProps(configurationElement);
             }
 
-            coverletSettings.ReportFormats = this.ParseReportFormats(configurationElement);
-            coverletSettings.ExcludeFilters = this.ParseExcludeFilters(configurationElement);
+            coverletSettings.ReportFormats = ParseReportFormats(configurationElement);
+            coverletSettings.ExcludeFilters = ParseExcludeFilters(configurationElement);
 
             if (_eqtTrace.IsVerboseEnabled)
             {
@@ -205,6 +206,18 @@ private bool ParseIncludeTestAssembly(XmlElement configurationElement)
             return includeTestAssembly;
         }
 
+        /// <summary>
+        /// Parse skipautoprops flag
+        /// </summary>
+        /// <param name="configurationElement">Configuration element</param>
+        /// <returns>Include Test Assembly Flag</returns>
+        private bool ParseSkipAutoProps(XmlElement configurationElement)
+        {
+            XmlElement skipAutoPropsElement = configurationElement[CoverletConstants.SkipAutoProps];
+            bool.TryParse(skipAutoPropsElement?.InnerText, out bool skipAutoProps);
+            return skipAutoProps;
+        }
+
         /// <summary>
         /// Splits a comma separated elements into an array
         /// </summary>

src/coverlet.collector/Utilities/CoverletConstants.cs

@@ -20,5 +20,6 @@ internal static class CoverletConstants
         public const string ReportFormatElementName = "Format";
         public const string DefaultExcludeFilter = "[coverlet.*]*";
         public const string InProcDataCollectorName = "CoverletInProcDataCollector";
+        public const string SkipAutoProps = "SkipAutoProps";
     }
 }

src/coverlet.console/Program.cs

@@ -60,6 +60,7 @@ static int Main(string[] args)
             CommandOption excludeAttributes = app.Option("--exclude-by-attribute", "Attributes to exclude from code coverage.", CommandOptionType.MultipleValue);
             CommandOption includeTestAssembly = app.Option("--include-test-assembly", "Specifies whether to report code coverage of the test assembly.", CommandOptionType.NoValue);
             CommandOption singleHit = app.Option("--single-hit", "Specifies whether to limit code coverage hit reporting to a single hit for each location", CommandOptionType.NoValue);
+            CommandOption skipAutoProp = app.Option("--skipautoprops", "Neither track nor record auto-implemented properties.", CommandOptionType.NoValue);
             CommandOption mergeWith = app.Option("--merge-with", "Path to existing coverage result to merge.", CommandOptionType.SingleValue);
             CommandOption useSourceLink = app.Option("--use-source-link", "Specifies whether to use SourceLink URIs in place of file system paths.", CommandOptionType.NoValue);
 
@@ -87,7 +88,8 @@ static int Main(string[] args)
                     IncludeTestAssembly = includeTestAssembly.HasValue(),
                     SingleHit = singleHit.HasValue(),
                     MergeWith = mergeWith.Value(),
-                    UseSourceLink = useSourceLink.HasValue()
+                    UseSourceLink = useSourceLink.HasValue(),
+                    SkipAutoProps = skipAutoProp.HasValue()
                 };
 
                 Coverage coverage = new Coverage(module.Value,
@@ -97,7 +99,7 @@ static int Main(string[] args)
                                                  fileSystem,
                                                  serviceProvider.GetRequiredService<ISourceRootTranslator>(),
                                                  serviceProvider.GetRequiredService<ICecilSymbolHelper>());
-                                                 coverage.PrepareModules();
+                coverage.PrepareModules();
 
                 Process process = new Process();
                 process.StartInfo.FileName = target.Value();

src/coverlet.core/Coverage.cs

@@ -23,6 +23,7 @@ internal class CoverageParameters
         public bool SingleHit { get; set; }
         public string MergeWith { get; set; }
         public bool UseSourceLink { get; set; }
+        public bool SkipAutoProps { get; set; }
     }
 
     internal class Coverage
@@ -38,6 +39,7 @@ internal class Coverage
         private bool _singleHit;
         private string _mergeWith;
         private bool _useSourceLink;
+        private bool _skipAutoProps;
         private ILogger _logger;
         private IInstrumentationHelper _instrumentationHelper;
         private IFileSystem _fileSystem;
@@ -73,6 +75,7 @@ public Coverage(string module,
             _fileSystem = fileSystem;
             _sourceRootTranslator = sourceRootTranslator;
             _cecilSymbolHelper = cecilSymbolHelper;
+            _skipAutoProps = parameters.SkipAutoProps;
 
             _identifier = Guid.NewGuid().ToString();
             _results = new List<InstrumenterResult>();
@@ -115,7 +118,19 @@ public CoveragePrepareResult PrepareModules()
                     continue;
                 }
 
-                var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, _excludedSourceFiles, _excludeAttributes, _singleHit, _logger, _instrumentationHelper, _fileSystem, _sourceRootTranslator, _cecilSymbolHelper);
+                var instrumenter = new Instrumenter(module,
+                                                    _identifier,
+                                                    _excludeFilters,
+                                                    _includeFilters,
+                                                    _excludedSourceFiles,
+                                                    _excludeAttributes,
+                                                    _singleHit,
+                                                    _skipAutoProps,
+                                                    _logger,
+                                                    _instrumentationHelper,
+                                                    _fileSystem,
+                                                    _sourceRootTranslator,
+                                                    _cecilSymbolHelper);
 
                 if (instrumenter.CanInstrument())
                 {

src/coverlet.core/Instrumentation/Instrumenter.cs

@@ -25,6 +25,7 @@ internal class Instrumenter
         private readonly ExcludedFilesHelper _excludedFilesHelper;
         private readonly string[] _excludedAttributes;
         private readonly bool _singleHit;
+        private readonly bool _skipAutoProps;
         private readonly bool _isCoreLibrary;
         private readonly ILogger _logger;
         private readonly IInstrumentationHelper _instrumentationHelper;
@@ -55,6 +56,7 @@ public Instrumenter(
             string[] excludedFiles,
             string[] excludedAttributes,
             bool singleHit,
+            bool skipAutoProps,
             ILogger logger,
             IInstrumentationHelper instrumentationHelper,
             IFileSystem fileSystem,
@@ -84,6 +86,7 @@ public Instrumenter(
             _fileSystem = fileSystem;
             _sourceRootTranslator = sourceRootTranslator;
             _cecilSymbolHelper = cecilSymbolHelper;
+            _skipAutoProps = skipAutoProps;
         }
 
         public bool CanInstrument()
@@ -432,6 +435,11 @@ private void InstrumentType(TypeDefinition type)
 
                 if (actualMethod.IsGetter || actualMethod.IsSetter)
                 {
+                    if (_skipAutoProps && actualMethod.CustomAttributes.Any(ca => ca.AttributeType.FullName == typeof(CompilerGeneratedAttribute).FullName))
+                    {
+                        continue;
+                    }
+
                     PropertyDefinition prop = type.Properties.FirstOrDefault(p => (p.GetMethod ?? p.SetMethod).FullName.Equals(actualMethod.FullName));
                     if (prop?.HasCustomAttributes == true)
                         customAttributes = customAttributes.Union(prop.CustomAttributes);