Merge remote-tracking branch 'origin/Issue5109_Consolidate_copy_command_logic' into nextIntoIssue5109

Author: IvenBach

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

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
@@ -105,7 +104,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/InspectionResultBase.cs

@@ -11,7 +11,7 @@
 
 namespace Rubberduck.Inspections.Abstract
 {
-    public abstract class InspectionResultBase : IInspectionResult, INavigateSource, IExportable
+    public abstract class InspectionResultBase : IInspectionResult, INavigateSource
     {
         protected InspectionResultBase(IInspection inspection,
             string description,
@@ -56,39 +56,6 @@ public int CompareTo(IInspectionResult other)
             return Inspection.CompareTo(other.Inspection);
         }
 
-        /// <summary>
-        /// WARNING: This property can have side effects. It can change the ActiveVBProject if the result has a null Declaration, 
-        /// which causes a flicker in the VBE. This should only be called if it is *absolutely* necessary.
-        /// </summary>
-        public string ToClipboardString()
-        {           
-            var module = QualifiedSelection.QualifiedName;
-            var documentName = Target != null 
-                ? Target.ProjectDisplayName 
-                : string.Empty;
-            //todo: Find a sane way to reimplement this.
-            //if (string.IsNullOrEmpty(documentName))
-            //{
-            //    var component = module.Component;
-            //    documentName = component != null 
-            //        ? component.ParentProject.ProjectDisplayName 
-            //        : string.Empty;
-            //}
-            if (string.IsNullOrEmpty(documentName))
-            {
-                documentName = Path.GetFileName(module.ProjectPath);
-            }
-
-            return string.Format(
-                InspectionsUI.QualifiedSelectionInspection,
-                Inspection.Severity,
-                Description,
-                $"({documentName})",
-                module.ProjectName,
-                module.ComponentName,
-                QualifiedSelection.Selection.StartLine);
-        }
-
         private NavigateCodeEventArgs _navigationArgs;
         public NavigateCodeEventArgs GetNavigationArgs()
         {
@@ -105,11 +72,5 @@ public int CompareTo(object obj)
         {
             return CompareTo(obj as IInspectionResult);
         }
-
-        public object[] ToArray()
-        {
-            var module = QualifiedSelection.QualifiedName;
-            return new object[] { Inspection.Severity.ToString(), module.ProjectName, module.ComponentName, Description, QualifiedSelection.Selection.StartLine, QualifiedSelection.Selection.StartColumn };
-        }
     }
 }

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),