Pass along result properties to the ResultDescription method of the identifier reference inspection base classes

Also moves further inspections to the base classes.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Abstract/ArgumentReferenceInspectionFromDeclarationsBase.cs

@@ -19,15 +19,11 @@ protected virtual (bool isResult, object properties) IsUnsuitableArgumentWithAdd
             return (IsUnsuitableArgument(reference, finder), null);
         }
 
-        protected override IEnumerable<(IdentifierReference reference, object properties)> ObjectionableReferences(DeclarationFinder finder)
+        protected override IEnumerable<IdentifierReference> ObjectionableReferences(DeclarationFinder finder)
         {
             return ObjectionableDeclarations(finder)
-                .OfType<ModuleBodyElementDeclaration>()
-                .SelectMany(declaration => declaration.Parameters)
-                .SelectMany(parameter => parameter.ArgumentReferences)
-                .Select(reference => (reference, IsResultReferenceWithAdditionalProperties(reference, finder)))
-                .Where(tpl => tpl.Item2.isResult)
-                .Select(tpl => ((IdentifierReference) tpl.reference, tpl.Item2.properties)); ;
+                .OfType<ParameterDeclaration>()
+                .SelectMany(parameter => parameter.ArgumentReferences);
         }
 
         protected override (bool isResult, object properties) IsResultReferenceWithAdditionalProperties(IdentifierReference reference, DeclarationFinder finder)

Rubberduck.CodeAnalysis/Inspections/Abstract/IdentifierReferenceInspectionBase.cs

@@ -16,7 +16,7 @@ public IdentifierReferenceInspectionBase(RubberduckParserState state)
         {}
 
         protected abstract bool IsResultReference(IdentifierReference reference, DeclarationFinder finder);
-        protected abstract string ResultDescription(IdentifierReference reference);
+        protected abstract string ResultDescription(IdentifierReference reference, dynamic properties = null);
 
         protected virtual (bool isResult, object properties) IsResultReferenceWithAdditionalProperties(IdentifierReference reference, DeclarationFinder finder)
         {
@@ -69,7 +69,7 @@ protected virtual IInspectionResult InspectionResult(IdentifierReference referen
         {
             return new IdentifierReferenceInspectionResult(
                 this,
-                ResultDescription(reference),
+                ResultDescription(reference, properties),
                 declarationFinderProvider,
                 reference,
                 properties);

Rubberduck.CodeAnalysis/Inspections/Abstract/IdentifierReferenceInspectionFromDeclarationsBase.cs

@@ -16,27 +16,33 @@ protected IdentifierReferenceInspectionFromDeclarationsBase(RubberduckParserStat
         {}
 
         protected abstract IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder);
-        protected abstract string ResultDescription(IdentifierReference reference);
+        protected abstract string ResultDescription(IdentifierReference reference, dynamic properties = null);
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var finder = DeclarationFinderProvider.DeclarationFinder;
             var objectionableReferences = ObjectionableReferences(finder);
-            return objectionableReferences
+            var resultReferences = ResultReferences(objectionableReferences, finder);
+            return resultReferences
                 .Select(tpl => InspectionResult(tpl.reference, DeclarationFinderProvider, tpl.properties))
                 .ToList();
         }
 
-        protected virtual IEnumerable<(IdentifierReference reference, object properties)> ObjectionableReferences(DeclarationFinder finder)
+        private IEnumerable<(IdentifierReference reference, object properties)> ResultReferences(IEnumerable<IdentifierReference> potentialResultReferences, DeclarationFinder finder)
         {
-            var objectionableDeclarations = ObjectionableDeclarations(finder);
-            return objectionableDeclarations
-                .SelectMany(declaration => declaration.References)
+            return potentialResultReferences
                 .Select(reference => (reference, IsResultReferenceWithAdditionalProperties(reference, finder)))
                 .Where(tpl => tpl.Item2.isResult)
                 .Select(tpl => (tpl.reference, tpl.Item2.properties));
         }
 
+        protected virtual IEnumerable<IdentifierReference> ObjectionableReferences(DeclarationFinder finder)
+        {
+            var objectionableDeclarations = ObjectionableDeclarations(finder);
+            return objectionableDeclarations
+                .SelectMany(declaration => declaration.References);
+        }
+
         protected virtual bool IsResultReference(IdentifierReference reference, DeclarationFinder finder) => true;
 
         protected virtual (bool isResult, object properties) IsResultReferenceWithAdditionalProperties(IdentifierReference reference, DeclarationFinder finder)
@@ -47,9 +53,10 @@ protected virtual (bool isResult, object properties) IsResultReferenceWithAdditi
         protected IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
         {
             var finder = DeclarationFinderProvider.DeclarationFinder;
-            var objectionableReferences = ObjectionableReferences(finder);
-            return objectionableReferences
-                .Where(tpl => tpl.reference.QualifiedModuleName.Equals(module))
+            var objectionableReferences = ObjectionableReferences(finder)
+                .Where(reference => reference.QualifiedModuleName.Equals(module));
+            var resultReferences = ResultReferences(objectionableReferences, finder);
+            return resultReferences
                 .Select(tpl => InspectionResult(tpl.reference, DeclarationFinderProvider, tpl.properties))
                 .ToList();
         }
@@ -58,7 +65,7 @@ protected virtual IInspectionResult InspectionResult(IdentifierReference referen
         {
             return new IdentifierReferenceInspectionResult(
                 this,
-                ResultDescription(reference),
+                ResultDescription(reference, properties),
                 declarationFinderProvider,
                 reference,
                 properties);

Rubberduck.CodeAnalysis/Inspections/Abstract/IsMissingInspectionBase.cs

@@ -48,9 +48,11 @@ protected IReadOnlyList<Declaration> IsMissingDeclarations(DeclarationFinder fin
             var isMissing = informationModules
                 .SelectMany(module => module.Members)
                 .Where(decl => IsMissingQualifiedNames.Contains(decl.QualifiedName.ToString()))
-                .ToList();
+                .OfType<ModuleBodyElementDeclaration>();
 
-            return isMissing;
+            return isMissing
+                .SelectMany(declaration => declaration.Parameters)
+                .ToList();
         }
 
         protected ParameterDeclaration ParameterForReference(ArgumentReference reference, DeclarationFinder finder)

Rubberduck.CodeAnalysis/Inspections/Abstract/MemberAccessMayReturnNothingInspectionBase.cs

@@ -100,7 +100,7 @@ private static IEnumerable<INode> GetReferenceNodes(INode node)
             }
         }
 
-        protected override string ResultDescription(IdentifierReference reference)
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
         {
             var semiQualifiedName = $"{reference.Declaration.ParentDeclaration.IdentifierName}.{reference.IdentifierName}";
             return string.Format(ResultTemplate, semiQualifiedName);

Rubberduck.CodeAnalysis/Inspections/Concrete/ArgumentWithIncompatibleObjectTypeInspection.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Inspections.Abstract;
 using Rubberduck.Inspections.Inspections.Extensions;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Grammar;
@@ -77,53 +78,47 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
 	/// End Sub
 	/// ]]>
 	/// </example>
-    public class ArgumentWithIncompatibleObjectTypeInspection : InspectionBase
+    public class ArgumentWithIncompatibleObjectTypeInspection : ArgumentReferenceInspectionFromDeclarationsBase
     {
-        private readonly IDeclarationFinderProvider _declarationFinderProvider;
         private readonly ISetTypeResolver _setTypeResolver;
 
         public ArgumentWithIncompatibleObjectTypeInspection(RubberduckParserState state, ISetTypeResolver setTypeResolver)
             : base(state)
         {
-            _declarationFinderProvider = state;
             _setTypeResolver = setTypeResolver;
 
             //This will most likely cause a runtime error. The exceptions are rare and should be refactored or made explicit with an @Ignore annotation.
             Severity = CodeInspectionSeverity.Error;
         }
 
-        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        protected override IEnumerable<Declaration> ObjectionableDeclarations(DeclarationFinder finder)
         {
-            var finder = _declarationFinderProvider.DeclarationFinder;
-
-            var strictlyTypedObjectParameters = finder.DeclarationsWithType(DeclarationType.Parameter)
-                .Where(ToBeConsidered)
-                .OfType<ParameterDeclaration>();
-
-            var offendingArguments = strictlyTypedObjectParameters
-                .SelectMany(param => param.ArgumentReferences)
-                .Select(argumentReference => ArgumentReferenceWithArgumentTypeName(argumentReference, finder))
-                .Where(argumentReferenceWithTypeName =>  argumentReferenceWithTypeName.argumentTypeName != null
-                                                         && !ArgumentPossiblyLegal(
-                                                             argumentReferenceWithTypeName.argumentReference.Declaration, 
-                                                             argumentReferenceWithTypeName.argumentTypeName));
-
-            return offendingArguments
-                // Ignoring the Declaration disqualifies all assignments
-                .Where(argumentReferenceWithTypeName => !argumentReferenceWithTypeName.Item1.Declaration.IsIgnoringInspectionResultFor(AnnotationName))
-                .Select(argumentReference => InspectionResult(argumentReference, _declarationFinderProvider));
+            return finder.DeclarationsWithType(DeclarationType.Parameter)
+                .Where(ToBeConsidered);
         }
 
         private static bool ToBeConsidered(Declaration declaration)
         {
-            return declaration != null
-                   && declaration.AsTypeDeclaration != null
+            return declaration?.AsTypeDeclaration != null
                    && declaration.IsObject;
         }
 
-        private (IdentifierReference argumentReference, string argumentTypeName) ArgumentReferenceWithArgumentTypeName(IdentifierReference argumentReference, DeclarationFinder finder)
+        protected override (bool isResult, object properties) IsUnsuitableArgumentWithAdditionalProperties(ArgumentReference reference, DeclarationFinder finder)
         {
-            return (argumentReference, ArgumentSetTypeName(argumentReference, finder));
+            var argumentSetTypeName = ArgumentSetTypeName(reference, finder);
+
+            if (argumentSetTypeName == null || ArgumentPossiblyLegal(reference.Declaration, argumentSetTypeName))
+            {
+                return (false, null);
+            }
+
+            return (true, argumentSetTypeName);
+        }
+
+        protected override bool IsUnsuitableArgument(ArgumentReference reference, DeclarationFinder finder)
+        {
+            //No need to implement this since we overwrite IsUnsuitableArgumentWithAdditionalProperties.
+            throw new System.NotImplementedException();
         }
 
         private string ArgumentSetTypeName(IdentifierReference argumentReference, DeclarationFinder finder)
@@ -146,7 +141,7 @@ private bool ArgumentPossiblyLegal(Declaration parameterDeclaration , string ass
                 || HasSubType(parameterDeclaration, assignedTypeName);
         }
 
-        private bool HasBaseType(Declaration declaration, string typeName)
+        private static bool HasBaseType(Declaration declaration, string typeName)
         {
             var ownType = declaration.AsTypeDeclaration;
             if (ownType == null || !(ownType is ClassModuleDeclaration classType))
@@ -157,7 +152,7 @@ private bool HasBaseType(Declaration declaration, string typeName)
             return classType.Subtypes.Select(subtype => subtype.QualifiedModuleName.ToString()).Contains(typeName);
         }
 
-        private bool HasSubType(Declaration declaration, string typeName)
+        private static bool HasSubType(Declaration declaration, string typeName)
         {
             var ownType = declaration.AsTypeDeclaration;
             if (ownType == null || !(ownType is ClassModuleDeclaration classType))
@@ -168,20 +163,12 @@ private bool HasSubType(Declaration declaration, string typeName)
             return classType.Supertypes.Select(supertype => supertype.QualifiedModuleName.ToString()).Contains(typeName);
         }
 
-        private IInspectionResult InspectionResult((IdentifierReference argumentReference, string argumentTypeName) argumentReferenceWithTypeName, IDeclarationFinderProvider declarationFinderProvider)
-        {
-            var (argumentReference, argumentTypeName) = argumentReferenceWithTypeName;
-            return new IdentifierReferenceInspectionResult(this,
-                ResultDescription(argumentReference, argumentTypeName),
-                declarationFinderProvider,
-                argumentReference);
-        }
-
-        private string ResultDescription(IdentifierReference argumentReference, string argumentTypeName)
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
         {
-            var parameterName = argumentReference.Declaration.IdentifierName;
-            var parameterTypeName = argumentReference.Declaration.FullAsTypeName;
-            var argumentExpression = argumentReference.Context.GetText();
+            var parameterName = reference.Declaration.IdentifierName;
+            var parameterTypeName = reference.Declaration.FullAsTypeName;
+            var argumentExpression = reference.Context.GetText();
+            var argumentTypeName = (string)properties;
             return string.Format(InspectionResults.SetAssignmentWithIncompatibleObjectTypeInspection, parameterName, parameterTypeName, argumentExpression, argumentTypeName);
         }
     }

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -105,7 +105,7 @@ private static bool IsAssignmentOfNothing(IdentifierReference reference)
                 && setStmtContext.expression().GetText().Equals(Tokens.Nothing);
         }
 
-        protected override string ResultDescription(IdentifierReference reference)
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
         {
             return Description;
         }

Rubberduck.CodeAnalysis/Inspections/Concrete/DefaultMemberRequiredInspection.cs

@@ -73,7 +73,7 @@ protected override bool IsResultReference(IdentifierReference failedIndexedDefau
             return true;
         }
 
-        protected override string ResultDescription(IdentifierReference failedIndexedDefaultMemberAccess)
+        protected override string ResultDescription(IdentifierReference failedIndexedDefaultMemberAccess, dynamic properties = null)
         {
             var expression = failedIndexedDefaultMemberAccess.IdentifierName;
             var typeName = failedIndexedDefaultMemberAccess.Declaration?.FullAsTypeName;

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

@@ -88,7 +88,7 @@ protected override IEnumerable<Declaration> ObjectionableDeclarations(Declaratio
                 .Where(decl => worksheetFunctionNames.Contains(decl.IdentifierName));
         }
 
-        protected override string ResultDescription(IdentifierReference reference)
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
         {
             return string.Format(InspectionResults.ApplicationWorksheetFunctionInspection, reference.IdentifierName);
         }

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

@@ -75,7 +75,7 @@ protected override IEnumerable<Declaration> ObjectionableDeclarations(Declaratio
             "Cells", "Range", "Columns", "Rows"
         };
 
-        protected override string ResultDescription(IdentifierReference reference)
+        protected override string ResultDescription(IdentifierReference reference, dynamic properties = null)
         {
             return string.Format(
                 InspectionResults.ImplicitActiveSheetReferenceInspection,