Merge pull request #5186 from Vogel612/fixes/inspection-ignore-consolidation

Centralizes ignore-handling for inspections

Author: retailcoder

Rubberduck.CodeAnalysis/Inspections/Abstract/IdentifierReferenceInspectionBase.cs

@@ -27,7 +27,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var results = new List<IInspectionResult>();
             foreach (var moduleDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Module))
             {
-                if (moduleDeclaration == null || moduleDeclaration.IsIgnoringInspectionResultFor(AnnotationName))
+                if (moduleDeclaration == null)
                 {
                     continue;
                 }

Rubberduck.CodeAnalysis/Inspections/Abstract/InspectionBase.cs

@@ -105,7 +105,9 @@ public IEnumerable<IInspectionResult> GetInspectionResults(CancellationToken tok
         {
             var _stopwatch = new Stopwatch();
             _stopwatch.Start();
-            var result = DoGetInspectionResults();
+            var declarationFinder = State.DeclarationFinder;
+            var result = DoGetInspectionResults()
+                .Where(ir => !ir.IsIgnoringInspectionResult(declarationFinder));
             _stopwatch.Stop();
             _logger.Trace("Intercepted invocation of '{0}.{1}' returned {2} objects.", GetType().Name, nameof(DoGetInspectionResults), result.Count());
             _logger.Trace("Intercepted invocation of '{0}.{1}' ran for {2}ms", GetType().Name, nameof(DoGetInspectionResults), _stopwatch.ElapsedMilliseconds);

Rubberduck.CodeAnalysis/Inspections/Abstract/MemberAccessMayReturnNothingInspectionBase.cs

@@ -29,7 +29,9 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             }
 
             var output = new List<IInspectionResult>();
-            foreach (var reference in interesting.Where(use => !use.IsIgnoringInspectionResultFor(AnnotationName)))
+            // prefilter to reduce search space
+            var prefilteredReferences = interesting.Where(use => !use.IsIgnoringInspectionResultFor(AnnotationName));
+            foreach (var reference in prefilteredReferences)
             {
                 var access = reference.Context.GetAncestor<VBAParser.MemberAccessExprContext>();
                 var usageContext = access.Parent is VBAParser.IndexExprContext

Rubberduck.CodeAnalysis/Inspections/Concrete/ArgumentWithIncompatibleObjectTypeInspection.cs

@@ -109,7 +109,8 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                                                              argumentReferenceWithTypeName.argumentTypeName));
 
             return offendingArguments
-                .Where(argumentReferenceWithTypeName => !IsIgnored(argumentReferenceWithTypeName.Item1))
+                // Ignoring the Declaration disqualifies all assignments
+                .Where(argumentReferenceWithTypeName => !argumentReferenceWithTypeName.Item1.Declaration.IsIgnoringInspectionResultFor(AnnotationName))
                 .Select(argumentReference => InspectionResult(argumentReference, _declarationFinderProvider));
         }
 
@@ -167,13 +168,6 @@ private bool HasSubType(Declaration declaration, string typeName)
             return classType.Supertypes.Select(supertype => supertype.QualifiedModuleName.ToString()).Contains(typeName);
         }
 
-        private bool IsIgnored(IdentifierReference assignment)
-        {
-            return assignment.IsIgnoringInspectionResultFor(AnnotationName)
-                   // Ignoring the Declaration disqualifies all assignments
-                   || assignment.Declaration.IsIgnoringInspectionResultFor(AnnotationName);
-        }
-
         private IInspectionResult InspectionResult((IdentifierReference argumentReference, string argumentTypeName) argumentReferenceWithTypeName, IDeclarationFinderProvider declarationFinderProvider)
         {
             var (argumentReference, argumentTypeName) = argumentReferenceWithTypeName;

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignedByValParameterInspection.cs

@@ -47,7 +47,6 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var parameters = State.DeclarationFinder.UserDeclarations(DeclarationType.Parameter)
                 .Cast<ParameterDeclaration>()
                 .Where(item => !item.IsByRef 
-                    && !item.IsIgnoringInspectionResultFor(AnnotationName)
                     && item.References.Any(reference => reference.IsAssignment));
 
             return parameters

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -71,9 +71,8 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             }
 
             return nodes
-                .Where(issue => !issue.IsIgnoringInspectionResultFor(AnnotationName)
-                            // Ignoring the Declaration disqualifies all assignments
-                            && !issue.Declaration.IsIgnoringInspectionResultFor(AnnotationName))
+                // Ignoring the Declaration disqualifies all assignments
+                .Where(issue => !issue.Declaration.IsIgnoringInspectionResultFor(AnnotationName))
                 .Select(issue => new IdentifierReferenceInspectionResult(this, Description, State, issue))
                 .ToList();
         }

Rubberduck.CodeAnalysis/Inspections/Concrete/BooleanAssignedInIfElseInspection.cs

@@ -48,7 +48,6 @@ public BooleanAssignedInIfElseInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             return Listener.Contexts
-                .Where(result => !result.IsIgnoringInspectionResultFor(State.DeclarationFinder, AnnotationName))
                 .Select(result => new QualifiedContextInspectionResult(this,
                                                        string.Format(InspectionResults.BooleanAssignedInIfElseInspection,
                                                             (((VBAParser.IfStmtContext)result.Context).block().GetDescendent<VBAParser.LetStmtContext>()).lExpression().GetText().Trim()),

Rubberduck.CodeAnalysis/Inspections/Concrete/ConstantNotUsedInspection.cs

@@ -46,8 +46,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var results = State.DeclarationFinder.UserDeclarations(DeclarationType.Constant)
                 .Where(declaration => declaration.Context != null
-                    && !declaration.References.Any()
-                    && !declaration.IsIgnoringInspectionResultFor(AnnotationName))
+                    && !declaration.References.Any())
                 .ToList();
 
             return results.Select(issue => 

Rubberduck.CodeAnalysis/Inspections/Concrete/DefTypeStatementInspection.cs

@@ -43,7 +43,7 @@ public DefTypeStatementInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var results = Listener.Contexts.Where(context => !context.IsIgnoringInspectionResultFor(State.DeclarationFinder, AnnotationName))
+            var results = Listener.Contexts
                 .Select(context => new QualifiedContextInspectionResult(this,
                                                                         string.Format(InspectionResults.DefTypeStatementInspection,
                                                                                       GetTypeOfDefType(context.Context.start.Text),

Rubberduck.CodeAnalysis/Inspections/Concrete/DefaultMemberRequiredInspection.cs

@@ -69,7 +69,7 @@ protected override IEnumerable<IdentifierReference> ReferencesInModule(Qualified
 
         protected override bool IsResultReference(IdentifierReference failedIndexedDefaultMemberAccess)
         {
-            return !failedIndexedDefaultMemberAccess.IsIgnoringInspectionResultFor(AnnotationName);
+            return true;
         }
 
         protected override string ResultDescription(IdentifierReference failedIndexedDefaultMemberAccess)