Remove declaration members and state from the InspectionBase

MDoerner · MDoerner · commit 7d620a87ef85 · 2020-02-26T13:45:40.000+01:00
The DeclarationFinderProvider remains protected for now.
diff --git a/Rubberduck.CodeAnalysis/Inspections/Abstract/IdentifierReferenceInspectionBase.cs b/Rubberduck.CodeAnalysis/Inspections/Abstract/IdentifierReferenceInspectionBase.cs
@@ -77,19 +77,9 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var finder = DeclarationFinderProvider.DeclarationFinder;
 
-            var results = new List<IInspectionResult>();
-            foreach (var moduleDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Module))
-            {
-                if (moduleDeclaration == null)
-                {
-                    continue;
-                }
-
-                var module = moduleDeclaration.QualifiedModuleName;
-                results.AddRange(DoGetInspectionResults(module, finder));
-            }
-
-            return results;
+            return finder.UserDeclarations(DeclarationType.Module)
+                .Where(module => module != null)
+                .SelectMany(module => DoGetInspectionResults(module.QualifiedModuleName, finder));
         }
 
         protected IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder)
diff --git a/Rubberduck.CodeAnalysis/Inspections/Abstract/InspectionBase.cs b/Rubberduck.CodeAnalysis/Inspections/Abstract/InspectionBase.cs
@@ -3,7 +3,6 @@
 using System.Globalization;
 using System.Linq;
 using Rubberduck.Parsing.Inspections.Abstract;
-using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
 using System.Diagnostics;
@@ -16,17 +15,15 @@ namespace Rubberduck.Inspections.Abstract
 {
     public abstract class InspectionBase : IInspection
     {
-        protected readonly RubberduckParserState State;
         protected readonly IDeclarationFinderProvider DeclarationFinderProvider;
 
         protected readonly ILogger Logger;
 
-        protected InspectionBase(RubberduckParserState state)
+        protected InspectionBase(IDeclarationFinderProvider declarationFinderProvider)
         {
             Logger = LogManager.GetLogger(GetType().FullName);
 
-            State = state;
-            DeclarationFinderProvider = state;
+            DeclarationFinderProvider = declarationFinderProvider;
             Name = GetType().Name;
         }
 
@@ -67,26 +64,6 @@ protected InspectionBase(RubberduckParserState state)
         /// </summary>
         public virtual string AnnotationName => Name.Replace("Inspection", string.Empty);
 
-        /// <summary>
-        /// Gets all declarations in the parser state without an @Ignore annotation for this inspection.
-        /// </summary>
-        protected virtual IEnumerable<Declaration> Declarations => DeclarationFinderProvider
-            .DeclarationFinder
-            .AllDeclarations
-            .Where(declaration => !declaration.IsIgnoringInspectionResultFor(AnnotationName));
-
-        /// <summary>
-        /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.
-        /// </summary>
-        protected virtual IEnumerable<Declaration> UserDeclarations => DeclarationFinderProvider
-            .DeclarationFinder
-            .AllUserDeclarations
-            .Where(declaration => !declaration.IsIgnoringInspectionResultFor(AnnotationName));
-
-        protected virtual IEnumerable<Declaration> BuiltInDeclarations => DeclarationFinderProvider
-            .DeclarationFinder
-            .AllBuiltInDeclarations;
-
         public int CompareTo(IInspection other) => string.Compare(InspectionType + Name, other.InspectionType + other.Name, StringComparison.Ordinal);
         public int CompareTo(object obj) => CompareTo(obj as IInspection);
 
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ApplicationWorksheetFunctionInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ApplicationWorksheetFunctionInspection.cs
@@ -63,18 +63,18 @@ public ApplicationWorksheetFunctionInspection(RubberduckParserState state)
 
         protected override IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder)
         {
-            var excel = State.DeclarationFinder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel");
+            var excel = finder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel");
             if (excel == null)
             {
                 return Enumerable.Empty<Declaration>();
             }
 
-            if (!(State.DeclarationFinder.FindClassModule("WorksheetFunction", excel, true) is ModuleDeclaration worksheetFunctionsModule))
+            if (!(finder.FindClassModule("WorksheetFunction", excel, true) is ModuleDeclaration worksheetFunctionsModule))
             {
                 return Enumerable.Empty<Declaration>();
             }
 
-            if (!(State.DeclarationFinder.FindClassModule("Application", excel, true) is ModuleDeclaration excelApplicationClass))
+            if (!(finder.FindClassModule("Application", excel, true) is ModuleDeclaration excelApplicationClass))
             {
                 return Enumerable.Empty<Declaration>();
             }
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ExcelUdfNameIsValidCellReferenceInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ExcelUdfNameIsValidCellReferenceInspection.cs
@@ -43,8 +43,11 @@ public ExcelUdfNameIsValidCellReferenceInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            if (!State.DeclarationFinder.Projects.Any(project => !project.IsUserDefined 
-                                                                 && project.IdentifierName == "Excel"))
+            //FIXME As-is, both this method and the base method get a declaration finder.
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
+            if (!finder.Projects.Any(project => !project.IsUserDefined 
+                                                         && project.IdentifierName == "Excel"))
             {
                 return Enumerable.Empty<IInspectionResult>();
             }
@@ -54,8 +57,11 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
         {
-            if (!State.DeclarationFinder.Projects.Any(project => !project.IsUserDefined
-                                                                 && project.IdentifierName == "Excel"))
+            //FIXME As-is, both this method and the base method get a declaration finder.
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
+            if (!finder.Projects.Any(project => !project.IsUserDefined
+                                                         && project.IdentifierName == "Excel"))
             {
                 return Enumerable.Empty<IInspectionResult>();
             }
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs
@@ -41,15 +41,21 @@ namespace Rubberduck.Inspections.Concrete
     /// </example>
     public sealed class IllegalAnnotationInspection : InspectionBase
     {
+        private readonly RubberduckParserState _state;
+
         public IllegalAnnotationInspection(RubberduckParserState state)
             : base(state)
-        {}
+        {
+            _state = state;
+        }
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var userDeclarations = State.DeclarationFinder.AllUserDeclarations.ToList();
-            var identifierReferences = State.DeclarationFinder.AllIdentifierReferences().ToList();
-            var annotations = State.AllAnnotations;
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
+            var userDeclarations = finder.AllUserDeclarations.ToList();
+            var identifierReferences = finder.AllIdentifierReferences().ToList();
+            var annotations = _state.AllAnnotations;
 
             var unboundAnnotations = UnboundAnnotations(annotations, userDeclarations, identifierReferences)
                 .Where(annotation => !annotation.Annotation.Target.HasFlag(AnnotationTarget.General)
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitByRefModifierInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitByRefModifierInspection.cs
@@ -56,8 +56,9 @@ protected override string ResultDescription(QualifiedContext<ParserRuleContext>
         protected override bool IsResultContext(QualifiedContext<ParserRuleContext> context)
         {
             //FIXME : This should really be a declaration inspection on the parameter. 
-            var builtInEventHandlerContexts = State.DeclarationFinder.FindEventHandlers().Select(handler => handler.Context).ToHashSet();
-            var interfaceImplementationMemberContexts = State.DeclarationFinder.FindAllInterfaceImplementingMembers().Select(member => member.Context).ToHashSet();
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+            var builtInEventHandlerContexts = finder.FindEventHandlers().Select(handler => handler.Context).ToHashSet();
+            var interfaceImplementationMemberContexts = finder.FindAllInterfaceImplementingMembers().Select(member => member.Context).ToHashSet();
 
             return !builtInEventHandlerContexts.Contains(context.Context.Parent.Parent)
                    && !interfaceImplementationMemberContexts.Contains(context.Context.Parent.Parent);
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ObjectWhereProcedureIsRequiredInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ObjectWhereProcedureIsRequiredInspection.cs
@@ -63,24 +63,21 @@ public ObjectWhereProcedureIsRequiredInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var results = new List<IInspectionResult>();
-            foreach (var moduleDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Module))
-            {
-                if (moduleDeclaration == null)
-                {
-                    continue;
-                }
-
-                var module = moduleDeclaration.QualifiedModuleName;
-                results.AddRange(DoGetInspectionResults(module));
-            }
+            var finder = DeclarationFinderProvider.DeclarationFinder;
 
-            return results;
+            return finder.UserDeclarations(DeclarationType.Module)
+                .Where(module => module != null)
+                .SelectMany(module => DoGetInspectionResults(module.QualifiedModuleName));
         }
 
         private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
         {
             var finder = DeclarationFinderProvider.DeclarationFinder;
+            return DoGetInspectionResults(module, finder);
+        }
+
+        private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder)
+        {
             return BoundInspectionResults(module, finder)
                 .Concat(UnboundInspectionResults(module, finder));
         }
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureCanBeWrittenAsFunctionInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ProcedureCanBeWrittenAsFunctionInspection.cs
@@ -59,13 +59,15 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                 return Enumerable.Empty<IInspectionResult>();
             }
 
-            var userDeclarations = State.AllUserDeclarations.ToList();
-            var builtinHandlers = State.DeclarationFinder.FindEventHandlers().ToList();
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
+            var userDeclarations = finder.AllUserDeclarations.ToList();
+            var builtinHandlers = finder.FindEventHandlers().ToList();
 
             var contextLookup = userDeclarations.Where(decl => decl.Context != null).ToDictionary(decl => decl.Context);
 
-            var ignored = new HashSet<Declaration>( State.DeclarationFinder.FindAllInterfaceMembers()
-                .Concat(State.DeclarationFinder.FindAllInterfaceImplementingMembers())
+            var ignored = new HashSet<Declaration>(finder.FindAllInterfaceMembers()
+                .Concat(finder.FindAllInterfaceImplementingMembers())
                 .Concat(builtinHandlers)
                 .Concat(userDeclarations.Where(item => item.IsWithEvents)));
 
@@ -76,7 +78,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                 .Where(decl => decl != null && 
                                 !ignored.Contains(decl) &&
                                 userDeclarations.Where(item => item.IsWithEvents)
-                                   .All(withEvents => !State.DeclarationFinder.FindHandlersForWithEventsField(withEvents).Any()) &&
+                                   .All(withEvents => !finder.FindHandlersForWithEventsField(withEvents).Any()) &&
                                !builtinHandlers.Contains(decl))
                 .Select(result => new DeclarationInspectionResult(this,
                     string.Format(InspectionResults.ProcedureCanBeWrittenAsFunctionInspection, result.IdentifierName),
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/RedundantByRefModifierInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/RedundantByRefModifierInspection.cs
@@ -62,8 +62,9 @@ protected override string ResultDescription(QualifiedContext<ParserRuleContext>
         protected override bool IsResultContext(QualifiedContext<ParserRuleContext> context)
         {
             //FIXME This should be an inspection on parameter declarations.
-            var builtInEventHandlerContexts = State.DeclarationFinder.FindEventHandlers().Select(handler => handler.Context).ToHashSet();
-            var interfaceImplementationMemberContexts = State.DeclarationFinder.FindAllInterfaceImplementingMembers().Select(member => member.Context).ToHashSet();
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+            var builtInEventHandlerContexts = finder.FindEventHandlers().Select(handler => handler.Context).ToHashSet();
+            var interfaceImplementationMemberContexts = finder.FindAllInterfaceImplementingMembers().Select(member => member.Context).ToHashSet();
 
             return !builtInEventHandlerContexts.Contains(context.Context.Parent.Parent)
                    && !interfaceImplementationMemberContexts.Contains(context.Context.Parent.Parent);
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/SuspiciousLetAssignmentInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/SuspiciousLetAssignmentInspection.cs
@@ -53,24 +53,21 @@ public SuspiciousLetAssignmentInspection(RubberduckParserState state)
 
         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))
-                {
-                    continue;
-                }
-
-                var module = moduleDeclaration.QualifiedModuleName;
-                results.AddRange(DoGetInspectionResults(module));
-            }
+            var finder = DeclarationFinderProvider.DeclarationFinder;
 
-            return results;
+            return finder.UserDeclarations(DeclarationType.Module)
+                .Where(module => module != null)
+                .SelectMany(module => DoGetInspectionResults(module.QualifiedModuleName, finder));
         }
 
         private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
         {
             var finder = DeclarationFinderProvider.DeclarationFinder;
+            return DoGetInspectionResults(module, finder);
+        }
+
+        private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder)
+        {
             return BoundLhsInspectionResults(module, finder)
                 .Concat(UnboundLhsInspectionResults(module, finder));
         }

Original file line number	Diff line number	Diff line change
`@@ -63,18 +63,18 @@ public ApplicationWorksheetFunctionInspection(RubberduckParserState state)`
`63`	`63`
`64`	`64`	`protected override IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder)`
`65`	`65`	`{`
`66`		`- var excel = State.DeclarationFinder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel");`
	`66`	`+ var excel = finder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel");`
`67`	`67`	`if (excel == null)`
`68`	`68`	`{`
`69`	`69`	`return Enumerable.Empty<Declaration>();`
`70`	`70`	`}`
`71`	`71`
`72`		`- if (!(State.DeclarationFinder.FindClassModule("WorksheetFunction", excel, true) is ModuleDeclaration worksheetFunctionsModule))`
	`72`	`+ if (!(finder.FindClassModule("WorksheetFunction", excel, true) is ModuleDeclaration worksheetFunctionsModule))`
`73`	`73`	`{`
`74`	`74`	`return Enumerable.Empty<Declaration>();`
`75`	`75`	`}`
`76`	`76`
`77`		`- if (!(State.DeclarationFinder.FindClassModule("Application", excel, true) is ModuleDeclaration excelApplicationClass))`
	`77`	`+ if (!(finder.FindClassModule("Application", excel, true) is ModuleDeclaration excelApplicationClass))`
`78`	`78`	`{`
`79`	`79`	`return Enumerable.Empty<Declaration>();`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,11 @@ public ExcelUdfNameIsValidCellReferenceInspection(RubberduckParserState state)`
`43`	`43`
`44`	`44`	`protected override IEnumerable<IInspectionResult> DoGetInspectionResults()`
`45`	`45`	`{`
`46`		`- if (!State.DeclarationFinder.Projects.Any(project => !project.IsUserDefined`
`47`		`- && project.IdentifierName == "Excel"))`
	`46`	`+ //FIXME As-is, both this method and the base method get a declaration finder.`
	`47`	`+ var finder = DeclarationFinderProvider.DeclarationFinder;`
	`48`	`+`
	`49`	`+ if (!finder.Projects.Any(project => !project.IsUserDefined`
	`50`	`+ && project.IdentifierName == "Excel"))`
`48`	`51`	`{`
`49`	`52`	`return Enumerable.Empty<IInspectionResult>();`
`50`	`53`	`}`
`@@ -54,8 +57,11 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()`
`54`	`57`
`55`	`58`	`protected override IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)`
`56`	`59`	`{`
`57`		`- if (!State.DeclarationFinder.Projects.Any(project => !project.IsUserDefined`
`58`		`- && project.IdentifierName == "Excel"))`
	`60`	`+ //FIXME As-is, both this method and the base method get a declaration finder.`
	`61`	`+ var finder = DeclarationFinderProvider.DeclarationFinder;`
	`62`	`+`
	`63`	`+ if (!finder.Projects.Any(project => !project.IsUserDefined`
	`64`	`+ && project.IdentifierName == "Excel"))`
`59`	`65`	`{`
`60`	`66`	`return Enumerable.Empty<IInspectionResult>();`
`61`	`67`	`}`