Make MissingAnnotationArguments use only the annotations

Also adds an overload of DeclarationFinder.FindAnnotations providing all annotations in a module. IllegalAnnotationInspection now uses this in favor of RubberduckParserState.GetAnnotations, which allows to remove the dependency on the state.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs

@@ -43,13 +43,9 @@ namespace Rubberduck.Inspections.Concrete
     /// </example>
     public sealed class IllegalAnnotationInspection : InspectionBase
     {
-        private readonly RubberduckParserState _state;
-
-        public IllegalAnnotationInspection(RubberduckParserState state)
-            : base(state)
-        {
-            _state = state;
-        }
+        public IllegalAnnotationInspection(IDeclarationFinderProvider declarationFinderProvider)
+            : base(declarationFinderProvider)
+        {}
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
@@ -70,7 +66,7 @@ private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleNam
         {
             var userDeclarations = finder.Members(module).ToList();
             var identifierReferences = finder.IdentifierReferences(module).ToList();
-            var annotations = _state.GetAnnotations(module);
+            var annotations = finder.FindAnnotations(module);
 
             var unboundAnnotations = UnboundAnnotations(annotations, userDeclarations, identifierReferences)
                 .Where(annotation => !annotation.Annotation.Target.HasFlag(AnnotationTarget.General)

Rubberduck.CodeAnalysis/Inspections/Concrete/MissingAnnotationArgumentInspection.cs

@@ -1,11 +1,15 @@
-using Antlr4.Runtime;
+using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing;
-using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Parsing.VBA.DeclarationCaching;
+using Rubberduck.VBEditor;
 
 namespace Rubberduck.Inspections.Concrete
 {
@@ -31,48 +35,57 @@ namespace Rubberduck.Inspections.Concrete
     /// ' ...
     /// ]]>
     /// </example>
-    public sealed class MissingAnnotationArgumentInspection : ParseTreeInspectionBase
+    public sealed class MissingAnnotationArgumentInspection : InspectionBase
     {
-        private readonly RubberduckParserState _state;
+        public MissingAnnotationArgumentInspection(IDeclarationFinderProvider declarationFinderProvider)
+            : base(declarationFinderProvider)
+        {}
 
-        public MissingAnnotationArgumentInspection(RubberduckParserState state)
-            : base(state)
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            _state = state;
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
+            return finder.UserDeclarations(DeclarationType.Module)
+                .Where(module => module != null)
+                .SelectMany(module => DoGetInspectionResults(module.QualifiedModuleName, finder))
+                .ToList();
         }
 
-        public override CodeKind TargetKindOfCode => CodeKind.AttributesCode;
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
+        {
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+            return DoGetInspectionResults(module, finder);
+        }
+
+        private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder)
+        {
+            var objectionableAnnotations = finder.FindAnnotations(module)
+                .Where(IsResultAnnotation);
 
-        public override IInspectionListener Listener { get; } =
-            new InvalidAnnotationStatementListener();
+            return objectionableAnnotations
+                .Select(InspectionResult)
+                .ToList();
+        }
 
-        protected override string ResultDescription(QualifiedContext<ParserRuleContext> context)
+        private static bool IsResultAnnotation(IParseTreeAnnotation pta)
         {
-            var expressionText = ((VBAParser.AnnotationContext) context.Context).annotationName().GetText();
-            return string.Format(
-                InspectionResults.MissingAnnotationArgumentInspection,
-                expressionText);
+            return pta.Annotation.RequiredArguments > pta.AnnotationArguments.Count;
         }
 
-        protected override bool IsResultContext(QualifiedContext<ParserRuleContext> context)
+        private IInspectionResult InspectionResult(IParseTreeAnnotation pta)
         {
-            // FIXME don't actually use listeners here, iterate the Annotations instead
-            // FIXME don't maintain a separate list for annotations that require arguments, instead use AnnotationAttribute to store that information
-            var annotationContext = (VBAParser.AnnotationContext) context.Context;
-            return (annotationContext.annotationName().GetText() == "Ignore"
-                    || annotationContext.annotationName().GetText() == "Folder")
-                    && annotationContext.annotationArgList() == null;
+            var qualifiedContext = new QualifiedContext(pta.QualifiedSelection.QualifiedName, pta.Context);
+            return new QualifiedContextInspectionResult(
+                this,
+                ResultDescription(pta),
+                qualifiedContext);
         }
 
-        public class InvalidAnnotationStatementListener : InspectionListenerBase
+        private static string ResultDescription(IParseTreeAnnotation pta)
         {
-            public override void ExitAnnotation(VBAParser.AnnotationContext context)
-            {
-                if (context.annotationName() != null)
-                {
-                    SaveContext(context);
-                }
-            }
+            return string.Format(
+                InspectionResults.MissingAnnotationArgumentInspection,
+                pta.Annotation.Name);
         }
     }
 }

Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs

@@ -68,9 +68,9 @@ private void FixNonModule(IInspectionResult result, IRewriteSession rewriteSessi
         {
             var module = result.QualifiedSelection.QualifiedName;
             var lineToAnnotate = result.QualifiedSelection.Selection.StartLine;
-            var existingIgnoreAnnotation = _state.DeclarationFinder.FindAnnotations(module, lineToAnnotate)
-                .Where(pta => pta.Annotation is IgnoreAnnotation)
-                .FirstOrDefault();
+            var existingIgnoreAnnotation = _state.DeclarationFinder
+                .FindAnnotations(module, lineToAnnotate)
+                .FirstOrDefault(pta => pta.Annotation is IgnoreAnnotation);
 
             var annotationInfo = new IgnoreAnnotation();
             if (existingIgnoreAnnotation != null)

Rubberduck.Parsing/VBA/DeclarationCaching/DeclarationFinder.cs

@@ -31,7 +31,7 @@ public class DeclarationFinder
         private readonly ConcurrentDictionary<QualifiedModuleName, IMutableFailedResolutionStore> _newFailedResolutionStores;
         private readonly ConcurrentDictionary<(QualifiedMemberName memberName, DeclarationType declarationType), ConcurrentBag<Declaration>> _newUndeclared;
 
-        private IDictionary<(QualifiedModuleName module, int annotatedLine), List<IParseTreeAnnotation>> _annotations;
+        private IDictionary<QualifiedModuleName,IDictionary<int, List<IParseTreeAnnotation>>> _annotations;
         private IDictionary<Declaration, List<ParameterDeclaration>> _parametersByParent;
         private IDictionary<DeclarationType, List<Declaration>> _userDeclarationsByType;
 
@@ -97,8 +97,9 @@ private List<Action> CollectionConstructionActions(IReadOnlyList<Declaration> de
             {
                 () =>
                     _annotations = annotations
-                        .Where(a => a.AnnotatedLine.HasValue)
-                        .GroupBy(a => (a.QualifiedSelection.QualifiedName, a.AnnotatedLine.Value))
+                        .GroupBy(annotation => annotation.QualifiedSelection.QualifiedName)
+                        .SelectMany(grp1 =>  grp1.GroupBy(annotation => annotation.AnnotatedLine.GetValueOrDefault(-1)), (grp1, grp2) => (grp1, grp2))
+                        .GroupBy(tpl => tpl.grp1.Key, tpl => tpl.grp2)
                         .ToDictionary(),
                 () =>
                     _declarations = declarations
@@ -518,11 +519,23 @@ public IEnumerable<Declaration> FindMemberMatches(Declaration parent, string mem
 
         public IEnumerable<IParseTreeAnnotation> FindAnnotations(QualifiedModuleName module, int annotatedLine)
         {
-            return _annotations.TryGetValue((module, annotatedLine), out var result) 
+            if(!_annotations.TryGetValue(module, out var annotationsByLineInModule))
+            {
+                return Enumerable.Empty<IParseTreeAnnotation>();
+            }
+
+            return annotationsByLineInModule.TryGetValue(annotatedLine, out var result) 
                 ? result 
                 : Enumerable.Empty<IParseTreeAnnotation>();
         }
 
+        public IEnumerable<IParseTreeAnnotation> FindAnnotations(QualifiedModuleName module)
+        {
+            return _annotations.TryGetValue(module, out var annotationsByLineInModule)
+                ? annotationsByLineInModule.AllValues()
+                : Enumerable.Empty<IParseTreeAnnotation>();
+        }
+
         public IEnumerable<IParseTreeAnnotation> FindAnnotations(QualifiedModuleName module, int annotatedLine, Type annotationType)
         {
             return FindAnnotations(module, annotatedLine).Where(pta => pta.Annotation.GetType() == annotationType);