Make IllegalAnnotationInspection work for individual modules

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs

@@ -9,6 +9,8 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
+using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.SafeComWrappers;
 
 namespace Rubberduck.Inspections.Concrete
@@ -53,27 +55,65 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var finder = DeclarationFinderProvider.DeclarationFinder;
 
-            var userDeclarations = finder.AllUserDeclarations.ToList();
-            var identifierReferences = finder.AllIdentifierReferences().ToList();
-            var annotations = _state.AllAnnotations;
+            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)
+        {
+            var userDeclarations = finder.Members(module).ToList();
+            var identifierReferences = finder.IdentifierReferences(module).ToList();
+            var annotations = _state.GetAnnotations(module);
 
             var unboundAnnotations = UnboundAnnotations(annotations, userDeclarations, identifierReferences)
                 .Where(annotation => !annotation.Annotation.Target.HasFlag(AnnotationTarget.General)
                                      || annotation.AnnotatedLine == null);
-            var attributeAnnotationsInDocuments = AttributeAnnotationsInDocuments(userDeclarations);
 
             var attributeAnnotationsOnDeclarationsNotAllowingAttributes = AttributeAnnotationsOnDeclarationsNotAllowingAttributes(userDeclarations);
 
             var illegalAnnotations = unboundAnnotations
-                .Concat(attributeAnnotationsInDocuments)
                 .Concat(attributeAnnotationsOnDeclarationsNotAllowingAttributes)
-                .ToHashSet();
+                .Distinct();
+
+            if (module.ComponentType == ComponentType.Document)
+            {
+                var attributeAnnotationsInDocuments = AttributeAnnotationsInDocuments(userDeclarations);
+                illegalAnnotations = illegalAnnotations
+                    .Concat(attributeAnnotationsInDocuments)
+                    .Distinct();
+            }
 
-            return illegalAnnotations.Select(annotation => 
-                new QualifiedContextInspectionResult(
-                    this, 
-                    string.Format(InspectionResults.IllegalAnnotationInspection, annotation.Context.annotationName().GetText()), 
-                    new QualifiedContext(annotation.QualifiedSelection.QualifiedName, annotation.Context)));
+            return illegalAnnotations
+                .Select(InspectionResult)
+                .ToList();
+        }
+
+        private IInspectionResult InspectionResult(IParseTreeAnnotation pta)
+        {
+            return new QualifiedContextInspectionResult(
+                this,
+                ResultDescription(pta),
+                Context(pta));
+        }
+
+        private static string ResultDescription(IParseTreeAnnotation pta)
+        {
+            var annotationText = pta.Context.annotationName().GetText();
+            return string.Format(
+                InspectionResults.IllegalAnnotationInspection,
+                annotationText);
+        }
+
+        private static QualifiedContext Context(IParseTreeAnnotation pta)
+        {
+            return new QualifiedContext(pta.QualifiedSelection.QualifiedName, pta.Context);
         }
 
         private static IEnumerable<IParseTreeAnnotation> UnboundAnnotations(IEnumerable<IParseTreeAnnotation> annotations, IEnumerable<Declaration> userDeclarations, IEnumerable<IdentifierReference> identifierReferences)
@@ -91,7 +131,8 @@ private static IEnumerable<IParseTreeAnnotation> AttributeAnnotationsInDocuments
         {
             var declarationsInDocuments = userDeclarations
                 .Where(declaration => declaration.QualifiedModuleName.ComponentType == ComponentType.Document);
-            return declarationsInDocuments.SelectMany(doc => doc.Annotations).Where(pta => pta.Annotation is IAttributeAnnotation);
+            return declarationsInDocuments.SelectMany(doc => doc.Annotations)
+                .Where(pta => pta.Annotation is IAttributeAnnotation);
         }
 
         private static IEnumerable<IParseTreeAnnotation> AttributeAnnotationsOnDeclarationsNotAllowingAttributes(IEnumerable<Declaration> userDeclarations)

Rubberduck.CodeAnalysis/Inspections/Concrete/MissingAnnotationArgumentInspection.cs

@@ -33,8 +33,13 @@ namespace Rubberduck.Inspections.Concrete
     /// </example>
     public sealed class MissingAnnotationArgumentInspection : ParseTreeInspectionBase
     {
+        private readonly RubberduckParserState _state;
+
         public MissingAnnotationArgumentInspection(RubberduckParserState state)
-            : base(state) { }
+            : base(state)
+        {
+            _state = state;
+        }
 
         public override CodeKind TargetKindOfCode => CodeKind.AttributesCode;
 

Rubberduck.Parsing/Annotations/AnnotationBase.cs

@@ -1,8 +1,5 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.Annotations
 {
@@ -12,7 +9,7 @@ public abstract class AnnotationBase : IAnnotation
         public string Name { get; }
         public AnnotationTarget Target { get; }
 
-        public AnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)
+        protected AnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)
         {
             Name = name;
             Target = target;

Rubberduck.Parsing/Annotations/IAnnotation.cs

@@ -1,6 +1,4 @@
-using Rubberduck.Parsing.Grammar;
-using Rubberduck.VBEditor;
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace Rubberduck.Parsing.Annotations

Rubberduck.Parsing/VBA/DeclarationResolving/DeclarationResolveRunnerBase.cs

@@ -139,7 +139,7 @@ protected void ResolveDeclarations(QualifiedModuleName module, IParseTree tree,
                 }
                 Logger.Debug($"Creating declarations for module {module.Name}.");
 
-                var annotationsOnWhiteSpaceLines = _state.GetModuleAnnotations(module)
+                var annotationsOnWhiteSpaceLines = _state.GetAnnotations(module)
                     .Where(a => a.AnnotatedLine.HasValue)
                     .GroupBy(a => a.AnnotatedLine.Value)
                     .ToDictionary();

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -687,7 +687,7 @@ public List<IParseTreeAnnotation> AllAnnotations
             }
         }
 
-        public IEnumerable<IParseTreeAnnotation> GetModuleAnnotations(QualifiedModuleName module)
+        public IEnumerable<IParseTreeAnnotation> GetAnnotations(QualifiedModuleName module)
         {
             if (_moduleStates.TryGetValue(module, out var result))
             {