Adding cmdline flag to validate unused diffs on baseline (#5147)

* Adding cmdline flag to validate unused diffs on baseline

* Update src/Microsoft.Cci.Extensions/Filters/BaselineDifferenceFilter.cs

Co-Authored-By: Eric StJohn <ericstj@microsoft.com>

* Update src/Microsoft.Cci.Extensions/Filters/BaselineDifferenceFilter.cs

Co-Authored-By: Eric StJohn <ericstj@microsoft.com>

Co-authored-by: Eric StJohn <ericstj@microsoft.com>

Author: gugavaro

src/Microsoft.Cci.Extensions/Filters/BaselineDifferenceFilter.cs

@@ -2,20 +2,24 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using Microsoft.Cci.Differs;
 
 namespace Microsoft.Cci.Filters
 {
     public class BaselineDifferenceFilter : IDifferenceFilter
     {
-        private readonly HashSet<string> _ignoreDifferences = new HashSet<string>();
+        private readonly Dictionary<string, bool> _ignoreDifferences = new Dictionary<string, bool>();
         private readonly IDifferenceFilter _filter;
+        private readonly bool _treatUnusedDifferencesAsIssues;
 
-        public BaselineDifferenceFilter(IDifferenceFilter filter)
+        public BaselineDifferenceFilter(IDifferenceFilter filter, bool treatUnusedDifferencesAsIssues)
         {
             _filter = filter;
+            _treatUnusedDifferencesAsIssues = treatUnusedDifferencesAsIssues;
         }
 
         public void AddBaselineFile(string baselineFile)
@@ -35,21 +39,40 @@ public void AddBaselineFile(string baselineFile)
                 if (string.IsNullOrWhiteSpace(filteredLine))
                     continue;
 
-                _ignoreDifferences.Add(filteredLine);
+                if (filteredLine.StartsWith("Compat issues with assembly", StringComparison.OrdinalIgnoreCase) || 
+                    filteredLine.StartsWith("Total Issues"))
+                    continue;
+
+                _ignoreDifferences[filteredLine] = false;
             }
         }
 
         public bool Include(Difference difference)
         {
             // Is the entire rule ignored?
-            if (_ignoreDifferences.Contains(difference.Id))
+            if (_ignoreDifferences.ContainsKey(difference.Id))
+            {
+                _ignoreDifferences[difference.Id] = true;
                 return false;
+            }
 
             // Is the specific violation of the rule ignored?
-            if (_ignoreDifferences.Contains(difference.ToString()))
+            var diff = difference.ToString();
+            if (_ignoreDifferences.ContainsKey(diff))
+            {
+                _ignoreDifferences[diff] = true;
                 return false;
+            }
 
             return _filter.Include(difference);
         }
+
+        public IEnumerable<string> GetUnusedBaselineDifferences()
+        {
+            if (!_treatUnusedDifferencesAsIssues)
+                return Enumerable.Empty<string>();
+
+            return _ignoreDifferences.Where(i => !i.Value).Select(i => i.Key);
+        }
     }
 }

src/Microsoft.Cci.Extensions/Traversers/DifferenceTraverser.cs

@@ -74,5 +74,7 @@ public virtual void Visit(IEnumerable<Difference> differences)
         public virtual void Visit(Difference difference)
         {
         }
+
+        protected IDifferenceFilter DifferenceFilter => _filter;
     }
 }

src/Microsoft.DotNet.ApiCompat/DifferenceWriter.cs

@@ -2,14 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
+using System.Composition;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using Microsoft.Cci.Differs;
 using Microsoft.Cci.Filters;
 using Microsoft.Cci.Mappings;
 using Microsoft.Cci.Traversers;
-using System.Composition;
 
 namespace Microsoft.Cci.Writers
 {
@@ -45,6 +47,20 @@ public void Write(string oldAssembliesName, IEnumerable<IAssembly> oldAssemblies
                 }
             }
 
+            if (DifferenceFilter is BaselineDifferenceFilter filter)
+            {
+                var unusedBaselineDifferences = filter.GetUnusedBaselineDifferences();
+                if (unusedBaselineDifferences.Any())
+                {
+                    _writer.WriteLine($"{Environment.NewLine}*** Invalid/Unused baseline differences ***");
+                    foreach (var diff in unusedBaselineDifferences)
+                    {
+                        _writer.WriteLine(diff);
+                        _totalDifferences++;
+                    }
+                }
+            }
+
             _writer.WriteLine("Total Issues: {0}", _totalDifferences);
             _totalDifferences = 0;
         }

src/Microsoft.DotNet.ApiCompat/Program.cs

@@ -40,6 +40,7 @@ public static int Main(string[] args)
             CommandOption implDirs = app.Option("-i|--impl-dirs", "Comma delimited list of directories to find the implementation assemblies for each contract assembly.", CommandOptionType.SingleValue);
             implDirs.IsRequired(allowEmptyStrings: true);
             CommandOption baseline = app.Option("-b|--baseline", "Comma delimited list of files to skip known diffs.", CommandOptionType.SingleValue);
+            CommandOption validateBaseline = app.Option("--validate-baseline", "Validates that baseline files don't have invalid/unused diffs.", CommandOptionType.NoValue);
             CommandOption mdil = app.Option("-m|--mdil", "Enforce MDIL servicing rules in addition to IL rules.", CommandOptionType.NoValue);
             CommandOption outFilePath = app.Option("-o|--out", "Output file path. Default is the console.", CommandOptionType.SingleValue);
             CommandOption leftOperand = app.Option("-l|--left-operand", "Name for left operand in comparison, default is 'contract'.", CommandOptionType.SingleValue);
@@ -94,7 +95,7 @@ public static int Main(string[] args)
 
                     try
                     {
-                        BaselineDifferenceFilter filter = GetBaselineDifferenceFilter(HostEnvironment.SplitPaths(baseline.Value()));
+                        BaselineDifferenceFilter filter = GetBaselineDifferenceFilter(HostEnvironment.SplitPaths(baseline.Value()), validateBaseline.HasValue());
                         NameTable sharedNameTable = new NameTable();
                         HostEnvironment contractHost = new HostEnvironment(sharedNameTable);
                         contractHost.UnableToResolve += (sender, e) => Trace.TraceError($"Unable to resolve assembly '{e.Unresolved}' referenced by the {leftOperandValue} assembly '{e.Referrer}'.");
@@ -191,20 +192,20 @@ bool RuleFilter(IDifferenceRuleMetadata ruleMetadata)
                 Implementation = rightOperand
             };
             ExportCciSettings.StaticAttributeFilter = GetAttributeFilter(HostEnvironment.SplitPaths(excludeAttributes));
-            ExportCciSettings.StaticRuleSettings = new RuleSettings { AllowDefaultInterfaceMethods = allowDefaultInterfaceMethods};
+            ExportCciSettings.StaticRuleSettings = new RuleSettings { AllowDefaultInterfaceMethods = allowDefaultInterfaceMethods };
 
             // Always compose the diff writer to allow it to import or provide exports
             container.SatisfyImports(diffWriter);
 
             return diffWriter;
         }
 
-        private static BaselineDifferenceFilter GetBaselineDifferenceFilter(string[] baselineFileNames)
+        private static BaselineDifferenceFilter GetBaselineDifferenceFilter(string[] baselineFileNames, bool validateBaseline)
         {
             BaselineDifferenceFilter baselineDifferenceFilter = null;
-            
-            AddFiles(baselineFileNames, (file) => 
-                (baselineDifferenceFilter ??= new BaselineDifferenceFilter(new DifferenceFilter<IncompatibleDifference>())).AddBaselineFile(file));
+
+            AddFiles(baselineFileNames, (file) =>
+                (baselineDifferenceFilter ??= new BaselineDifferenceFilter(new DifferenceFilter<IncompatibleDifference>(), validateBaseline)).AddBaselineFile(file));
 
             return baselineDifferenceFilter;
         }