Make the remaining identifier reference inspections use the base classes if apprpriate

Some are left as-is because using the base classes would hurt readablity.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ImplicitActiveWorkbookReferenceInspection.cs

@@ -1,13 +1,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Inspections.Abstract;
-using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Inspections;
-using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -38,7 +36,7 @@ namespace Rubberduck.Inspections.Concrete
     /// ]]>
     /// </example>
     [RequiredLibrary("Excel")]
-    public sealed class ImplicitActiveWorkbookReferenceInspection : InspectionBase
+    public sealed class ImplicitActiveWorkbookReferenceInspection : IdentifierReferenceInspectionFromDeclarationsBase
     {
         public ImplicitActiveWorkbookReferenceInspection(RubberduckParserState state)
             : base(state) { }
@@ -53,27 +51,31 @@ public ImplicitActiveWorkbookReferenceInspection(RubberduckParserState state)
             "_Global", "_Application", "Global", "Application"
         };
 
-        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        protected override IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder)
         {
-            var excel = State.DeclarationFinder.Projects.SingleOrDefault(item => !item.IsUserDefined && item.IdentifierName == "Excel");
+            var excel = finder.Projects
+                .SingleOrDefault(project => project.IdentifierName == "Excel" && !project.IsUserDefined);
             if (excel == null)
             {
-                return Enumerable.Empty<IInspectionResult>();
+                return Enumerable.Empty<Declaration>();
             }
 
-            var targetProperties = BuiltInDeclarations
+            var relevantClasses = InterestingClasses
+                .Select(className => finder.FindClassModule(className, excel, true))
+                .OfType<ModuleDeclaration>();
+
+            var relevantProperties = relevantClasses
+                .SelectMany(classDeclaration => classDeclaration.Members)
                 .OfType<PropertyGetDeclaration>()
-                .Where(x => InterestingMembers.Contains(x.IdentifierName) && InterestingClasses.Contains(x.ParentDeclaration?.IdentifierName))
-                .ToList();
+                .Where(member => InterestingMembers.Contains(member.IdentifierName));
 
-            // only inspects references, must filter ignores manually, because default filtering doesn't work here
-            var members = targetProperties.SelectMany(item =>
-                item.References.Where(reference => !reference.IsIgnoringInspectionResultFor(AnnotationName)));
+            return relevantProperties;
+        }
 
-            return members.Select(issue => new IdentifierReferenceInspectionResult(this,
-                                                                string.Format(InspectionResults.ImplicitActiveWorkbookReferenceInspection, issue.Context.GetText()),
-                                                                State,
-                                                                issue));
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
+        {
+            var referenceText = reference.Context.GetText();
+            return string.Format(InspectionResults.ImplicitActiveWorkbookReferenceInspection, referenceText);
         }
     }
 }

Rubberduck.CodeAnalysis/Inspections/Concrete/SuspiciousLetAssignmentInspection.cs

@@ -45,12 +45,9 @@ namespace Rubberduck.Inspections.Concrete
     /// </example>
     public sealed class SuspiciousLetAssignmentInspection : InspectionBase
     {
-        private readonly IDeclarationFinderProvider _declarationFinderProvider;
-
         public SuspiciousLetAssignmentInspection(RubberduckParserState state)
             : base(state)
         {
-            _declarationFinderProvider = state;
             Severity = CodeInspectionSeverity.Warning;
         }
 
@@ -73,7 +70,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
 
         private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
         {
-            var finder = _declarationFinderProvider.DeclarationFinder;
+            var finder = DeclarationFinderProvider.DeclarationFinder;
             return BoundLhsInspectionResults(module, finder)
                 .Concat(UnboundLhsInspectionResults(module, finder));
         }
@@ -92,7 +89,7 @@ private IEnumerable<IInspectionResult> BoundLhsInspectionResults(QualifiedModule
 
                 if (rhsDefaultMemberAccess != null)
                 {
-                    var result = InspectionResult(assignment, rhsDefaultMemberAccess, isUnbound, _declarationFinderProvider);
+                    var result = InspectionResult(assignment, rhsDefaultMemberAccess, isUnbound);
                     results.Add(result);
                 }
             }
@@ -133,12 +130,12 @@ private bool IsImplicitDefaultMemberAssignment(IdentifierReference reference)
             return (unboundRhsDefaultMemberAccess, true);
         }
 
-        private IInspectionResult InspectionResult(IdentifierReference lhsReference, IdentifierReference rhsReference, bool isUnbound, IDeclarationFinderProvider declarationFinderProvider)
+        private IInspectionResult InspectionResult(IdentifierReference lhsReference, IdentifierReference rhsReference, bool isUnbound)
         {
             var result = new IdentifierReferenceInspectionResult(
                 this,
                 ResultDescription(lhsReference, rhsReference),
-                declarationFinderProvider,
+                DeclarationFinderProvider,
                 lhsReference);
             result.Properties.RhSReference = rhsReference;
             if (isUnbound)
@@ -169,7 +166,7 @@ private IEnumerable<IInspectionResult> UnboundLhsInspectionResults(QualifiedModu
 
                 if (rhsDefaultMemberAccess != null)
                 {
-                    var result = InspectionResult(assignment, rhsDefaultMemberAccess, true, _declarationFinderProvider);
+                    var result = InspectionResult(assignment, rhsDefaultMemberAccess, true);
                     results.Add(result);
                 }
             }

Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs

@@ -4,12 +4,15 @@
 using Antlr4.Runtime;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
+using Rubberduck.JunkDrawer.Extensions;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
+using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -41,7 +44,7 @@ namespace Rubberduck.Inspections.Concrete
     /// ]]>
     /// </example>
     [SuppressMessage("ReSharper", "LoopCanBeConvertedToQuery")]
-    public sealed class UnassignedVariableUsageInspection : InspectionBase
+    public sealed class UnassignedVariableUsageInspection : IdentifierReferenceInspectionFromDeclarationsBase
     {
         public UnassignedVariableUsageInspection(RubberduckParserState state)
             : base(state) { }
@@ -55,32 +58,97 @@ public UnassignedVariableUsageInspection(RubberduckParserState state)
             "VBA6.DLL;VBA.Strings.LenB"
         };
 
-        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        protected override IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder)
         {
-            var declarations = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
-                .Where(declaration => !declaration.IsArray &&
-                    State.DeclarationFinder.MatchName(declaration.AsTypeName)
-                        .All(d => d.DeclarationType != DeclarationType.UserDefinedType)
-                    && !declaration.IsSelfAssigned
-                    && !declaration.References.Any(reference => reference.IsAssignment));
-
-            var excludedDeclarations = BuiltInDeclarations.Where(decl => IgnoredFunctions.Contains(decl.QualifiedName.ToString())).ToList();
-
-            return declarations
-                .Where(d => d.References.Any() && !excludedDeclarations.Any(excl => DeclarationReferencesContainsReference(excl, d)))
-                .SelectMany(d => d.References.Where(r => !IsAssignedByRefArgument(r.ParentScoping, r)))
-                .Distinct()
-                .Where(r => !r.Context.TryGetAncestor<VBAParser.RedimStmtContext>(out _) && !IsArraySubscriptAssignment(r))
-                .Select(r => new IdentifierReferenceInspectionResult(this,
-                    string.Format(InspectionResults.UnassignedVariableUsageInspection, r.IdentifierName),
-                    State,
-                    r)).ToList();
+            return finder.UserDeclarations(DeclarationType.Variable)
+                .Where(declaration => !declaration.IsArray
+                                      && !declaration.IsSelfAssigned
+                                      && finder.MatchName(declaration.AsTypeName)
+                                          .All(d => d.DeclarationType != DeclarationType.UserDefinedType)
+                                      && !declaration.References
+                                          .Any(reference => reference.IsAssignment));
         }
 
-        private bool IsAssignedByRefArgument(Declaration enclosingProcedure, IdentifierReference reference)
+        //We override this in order to look up the argument usage exclusion references only once.
+        protected override IEnumerable<IdentifierReference> ObjectionableReferences(DeclarationFinder finder)
+        {
+            var excludedReferenceSelections = DeclarationsWithExcludedArgumentUsage(finder)
+                .SelectMany(SingleVariableArgumentSelections)
+                .ToHashSet();
+
+            return base.ObjectionableReferences(finder)
+                .Where(reference => !excludedReferenceSelections.Contains(reference.QualifiedSelection));
+        }
+
+        private IEnumerable<ModuleBodyElementDeclaration> DeclarationsWithExcludedArgumentUsage(DeclarationFinder finder)
+        {
+            var vbaProjects = finder.Projects
+                .Where(project => project.IdentifierName == "VBA" && !project.IsUserDefined)
+                .ToList();
+
+            if (!vbaProjects.Any())
+            {
+                return new List<ModuleBodyElementDeclaration>();
+            }
+
+            var stringModules = vbaProjects
+                .Select(project => finder.FindStdModule("Strings", project, true))
+                .OfType<ModuleDeclaration>()
+                .ToList();
+
+            if (!stringModules.Any())
+            {
+                return new List<ModuleBodyElementDeclaration>();
+            }
+
+            return stringModules
+                .SelectMany(module => module.Members)
+                .Where(decl => IgnoredFunctions.Contains(decl.QualifiedName.ToString()))
+                .OfType<ModuleBodyElementDeclaration>();
+        }
+
+        private static IEnumerable<QualifiedSelection> SingleVariableArgumentSelections(ModuleBodyElementDeclaration member)
+        {
+            return member.Parameters
+                .SelectMany(parameter => parameter.ArgumentReferences)
+                .Select(SingleVariableArgumentSelection)
+                .Where(maybeSelection => maybeSelection.HasValue)
+                .Select(selection => selection.Value);
+        }
+
+        private static QualifiedSelection? SingleVariableArgumentSelection(ArgumentReference argumentReference)
+        {
+            var argumentContext = argumentReference.Context as VBAParser.LExprContext;
+            if (!(argumentContext?.lExpression() is VBAParser.SimpleNameExprContext name))
+            {
+                return null;
+            }
+
+            return new QualifiedSelection(argumentReference.QualifiedModuleName, name.GetSelection());
+        }
+
+        protected override bool IsResultReference(IdentifierReference reference, DeclarationFinder finder)
+        {
+            //FIXME: stop filtering out too many results.
+            return reference != null
+                   && !IsAssignedByRefArgument(reference.ParentScoping, reference, finder)
+                   && !IsArraySubscriptAssignment(reference) 
+                   && !reference.Context.TryGetAncestor<VBAParser.RedimStmtContext>(out _); 
+                
+        }
+
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
+        {
+            var identifierName = reference.IdentifierName;
+            return string.Format(
+                InspectionResults.UnassignedVariableUsageInspection,
+                identifierName);
+        }
+
+        private static bool IsAssignedByRefArgument(Declaration enclosingProcedure, IdentifierReference reference, DeclarationFinder finder)
         {
             var argExpression = reference.Context.GetAncestor<VBAParser.ArgumentExpressionContext>();
-            var parameter = State.DeclarationFinder.FindParameterOfNonDefaultMemberFromSimpleArgumentNotPassedByValExplicitly(argExpression, enclosingProcedure);
+            var parameter = finder.FindParameterOfNonDefaultMemberFromSimpleArgumentNotPassedByValExplicitly(argExpression, enclosingProcedure);
 
             // note: not recursive, by design.
             return parameter != null
@@ -90,28 +158,12 @@ private bool IsAssignedByRefArgument(Declaration enclosingProcedure, IdentifierR
 
         private static bool IsArraySubscriptAssignment(IdentifierReference reference)
         {
+            //FIXME: stop returning true for too many cases.
             var isLetAssignment = reference.Context.TryGetAncestor<VBAParser.LetStmtContext>(out var letStmt);
             var isSetAssignment = reference.Context.TryGetAncestor<VBAParser.SetStmtContext>(out var setStmt);
 
-            return isLetAssignment && letStmt.lExpression() is VBAParser.IndexExprContext ||
-                   isSetAssignment && setStmt.lExpression() is VBAParser.IndexExprContext;
-        }
-
-        private static bool DeclarationReferencesContainsReference(Declaration parentDeclaration, Declaration target)
-        {
-            foreach (var targetReference in target.References)
-            {
-                foreach (var reference in parentDeclaration.References)
-                {
-                    var context = (ParserRuleContext)reference.Context.Parent;
-                    if (context.GetSelection().Contains(targetReference.Selection))
-                    {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
+            return isLetAssignment && letStmt.lExpression() is VBAParser.IndexExprContext 
+                   || isSetAssignment && setStmt.lExpression() is VBAParser.IndexExprContext;
         }
     }
 }

Rubberduck.CodeAnalysis/Inspections/Concrete/UntypedFunctionUsageInspection.cs

@@ -1,9 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Inspections.Abstract;
-using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Grammar;
-using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.Symbols;
@@ -32,7 +30,7 @@ namespace Rubberduck.Inspections.Concrete
     /// End Sub
     /// ]]>
     /// </example>
-    public sealed class UntypedFunctionUsageInspection : InspectionBase
+    public sealed class UntypedFunctionUsageInspection : IdentifierReferenceInspectionFromDeclarationsBase
     {
         public UntypedFunctionUsageInspection(RubberduckParserState state)
             : base(state) { }
@@ -63,48 +61,37 @@ public UntypedFunctionUsageInspection(RubberduckParserState state)
             Tokens.UCase
         };
 
-        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        protected override IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder)
         {
-            var finder = State.DeclarationFinder;
-
-            var declarationsToConsider = BuiltInVariantStringFunctionsWithStringTypedVersion(finder);
-
-            return declarationsToConsider
-                .SelectMany(NonStringHintedReferences)
-                .Select(Result);
+            return BuiltInVariantStringFunctionsWithStringTypedVersion(finder);
         }
 
         private IEnumerable<Declaration> BuiltInVariantStringFunctionsWithStringTypedVersion(DeclarationFinder finder)
         {
             return finder
                 .BuiltInDeclarations(DeclarationType.Member)
-                .Where(item => (_tokens.Contains(item.IdentifierName)
-                                || item.IdentifierName.StartsWith("_B_var_")
-                                    && _tokens.Contains(item.IdentifierName.Substring("_B_var_".Length)))
-                               && item.Scope.StartsWith("VBE7.DLL;"));
+                .Where(item => item.Scope.StartsWith("VBE7.DLL;") 
+                               && (_tokens.Contains(item.IdentifierName)
+                                    || item.IdentifierName.StartsWith("_B_var_")
+                                        && _tokens.Contains(item.IdentifierName.Substring("_B_var_".Length))));
         }
 
-        private IEnumerable<IdentifierReference> NonStringHintedReferences(Declaration declaration)
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
         {
-            return declaration.References
-                .Where(item => _tokens.Contains(item.IdentifierName));
+            var declarationName = reference.Declaration.IdentifierName;
+            return string.Format(
+                InspectionResults.UntypedFunctionUsageInspection,
+                declarationName);
         }
 
-        private IInspectionResult Result(IdentifierReference reference)
+        protected override bool IsResultReference(IdentifierReference reference, DeclarationFinder finder)
         {
-            return new IdentifierReferenceInspectionResult(
-                this,
-                ResultDescription(reference),
-                State,
-                reference);
+            return IsNotStringHinted(reference);
         }
 
-        private static string ResultDescription(IdentifierReference reference)
+        private bool IsNotStringHinted(IdentifierReference reference)
         {
-            var declarationName = reference.Declaration.IdentifierName;
-            return string.Format(
-                InspectionResults.UntypedFunctionUsageInspection,
-                declarationName);
+            return _tokens.Contains(reference.IdentifierName);
         }
     }
 }