Add SuperfluousAnnotationArgumentsInspection

Also add allowed number of arguments to IAnnotation interface.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/MissingAnnotationArgumentInspection.cs

@@ -14,10 +14,10 @@
 namespace Rubberduck.Inspections.Concrete
 {
     /// <summary>
-    /// Warns about a malformed Rubberduck annotation that is missing an argument.
+    /// Warns about a malformed Rubberduck annotation that is missing one or more arguments.
     /// </summary>
     /// <why>
-    /// Some annotations require arguments; if the argument isn't specified, the annotation is nothing more than an obscure comment.
+    /// Some annotations require arguments; if the required number of arguments isn't specified, the annotation is nothing more than an obscure comment.
     /// </why>
     /// <example hasResults="true">
     /// <![CDATA[

Rubberduck.CodeAnalysis/Inspections/Concrete/SuperfluousAnnotationArgumentInspection.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing;
+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.DeclarationCaching;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Warns about Rubberduck annotations with more arguments than allowed.
+    /// </summary>
+    /// <why>
+    /// Most annotations only process a limited number of arguments; superfluous arguments are ignored.
+    /// </why>
+    /// <example hasResults="true">
+    /// <![CDATA[
+    /// '@Folder "MyFolder.MySubFolder" "SomethingElse
+    /// '@PredeclaredId True
+    /// Option Explicit
+    /// ' ...
+    /// ]]>
+    /// </example>
+    /// <example hasResults="false">
+    /// <![CDATA[
+    /// '@Folder("MyFolder.MySubFolder")
+    /// '@PredeclaredId
+    /// Option Explicit
+    /// ' ...
+    /// ]]>
+    /// </example>
+    public sealed class SuperfluousAnnotationArgumentInspection : InspectionBase
+    {
+        public SuperfluousAnnotationArgumentInspection(IDeclarationFinderProvider declarationFinderProvider)
+            : base(declarationFinderProvider)
+        {}
+
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        {
+            var finder = DeclarationFinderProvider.DeclarationFinder;
+
+            return finder.UserDeclarations(DeclarationType.Module)
+                .Where(module => module != null)
+                .SelectMany(module => DoGetInspectionResults(module.QualifiedModuleName, finder))
+                .ToList();
+        }
+
+        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);
+
+            return objectionableAnnotations
+                .Select(InspectionResult)
+                .ToList();
+        }
+
+        private static bool IsResultAnnotation(IParseTreeAnnotation pta)
+        {
+            var allowedArguments = pta.Annotation.AllowedArguments;
+            return allowedArguments.HasValue && allowedArguments.Value < pta.AnnotationArguments.Count;
+        }
+
+        private IInspectionResult InspectionResult(IParseTreeAnnotation pta)
+        {
+            var qualifiedContext = new QualifiedContext(pta.QualifiedSelection.QualifiedName, pta.Context);
+            return new QualifiedContextInspectionResult(
+                this,
+                ResultDescription(pta),
+                qualifiedContext);
+        }
+
+        private static string ResultDescription(IParseTreeAnnotation pta)
+        {
+            return string.Format(
+                InspectionResults.SuperfluousAnnotationArgumentInspection,
+                pta.Annotation.Name);
+        }
+    }
+}

Rubberduck.Parsing/Annotations/AnnotationBase.cs

@@ -7,15 +7,17 @@ public abstract class AnnotationBase : IAnnotation
     {
         public bool AllowMultiple { get; }
         public int RequiredArguments { get; }
+        public int? AllowedArguments { get; }
         public string Name { get; }
         public AnnotationTarget Target { get; }
 
-        protected AnnotationBase(string name, AnnotationTarget target, int requiredArguments = 0, bool allowMultiple = false)
+        protected AnnotationBase(string name, AnnotationTarget target, int requiredArguments = 0, int? allowedArguments = 0, bool allowMultiple = false)
         {
             Name = name;
             Target = target;
             AllowMultiple = allowMultiple;
             RequiredArguments = requiredArguments;
+            AllowedArguments = allowedArguments;
         }
 
         public virtual IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments)

Rubberduck.Parsing/Annotations/Concrete/FlexibleAttributeAnnotationBase.cs

@@ -7,7 +7,7 @@ namespace Rubberduck.Parsing.Annotations
     public abstract class FlexibleAttributeAnnotationBase : AnnotationBase, IAttributeAnnotation
     {
         protected FlexibleAttributeAnnotationBase(string name, AnnotationTarget target, bool allowMultiple = false)
-            : base(name, target, 2, allowMultiple) //We need at least the attribute name and one value for it.
+            : base(name, target, 2, null, allowMultiple) //We need at least the attribute name and one value for it.
         {}
 
         public IReadOnlyList<string> AnnotationToAttributeValues(IReadOnlyList<string> annotationValues)

Rubberduck.Parsing/Annotations/Concrete/FlexibleAttributeValueAnnotationBase.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Common;
 
@@ -11,7 +10,7 @@ public abstract class FlexibleAttributeValueAnnotationBase : AnnotationBase, IAt
         private readonly int _numberOfValues;
 
         protected FlexibleAttributeValueAnnotationBase(string name, AnnotationTarget target, string attribute, int numberOfValues)
-            : base(name, target, numberOfValues)
+            : base(name, target, numberOfValues, numberOfValues)
         {
             _attribute = attribute;
             _numberOfValues = numberOfValues;

Rubberduck.Parsing/Annotations/Concrete/FolderAnnotation.cs

@@ -6,7 +6,7 @@
     public sealed class FolderAnnotation : AnnotationBase
     {
         public FolderAnnotation()
-            : base("Folder", AnnotationTarget.Module, 1)
+            : base("Folder", AnnotationTarget.Module, 1, 1)
         {}
     }
 }

Rubberduck.Parsing/Annotations/Concrete/IgnoreAnnotation.cs

@@ -6,7 +6,7 @@
     public sealed class IgnoreAnnotation : AnnotationBase
     {
         public IgnoreAnnotation()
-            : base("Ignore", AnnotationTarget.General, 1, true)
+            : base("Ignore", AnnotationTarget.General, 1, null, true)
         {}
     }
 }

Rubberduck.Parsing/Annotations/Concrete/IgnoreModuleAnnotation.cs

@@ -6,7 +6,7 @@
     public sealed class IgnoreModuleAnnotation : AnnotationBase
     {
         public IgnoreModuleAnnotation()
-            : base("IgnoreModule", AnnotationTarget.Module, 1, true)
+            : base("IgnoreModule", AnnotationTarget.Module, allowedArguments: null, allowMultiple: true)
         {}
     }
 }

Rubberduck.Parsing/Annotations/Concrete/IgnoreTestAnnotation.cs

@@ -6,7 +6,7 @@
     public sealed class IgnoreTestAnnotation : AnnotationBase
     {
         public IgnoreTestAnnotation()
-            : base("IgnoreTest", AnnotationTarget.Member)
-        { }
+            : base("IgnoreTest", AnnotationTarget.Member, allowedArguments: 1)
+        {}
     }
 }

Rubberduck.Parsing/Annotations/Concrete/ObsoleteAnnotation.cs

@@ -12,7 +12,7 @@ public sealed class ObsoleteAnnotation : AnnotationBase
         public string ReplacementDocumentation { get; private set; }
 
         public ObsoleteAnnotation()
-            : base("Obsolete", AnnotationTarget.Member | AnnotationTarget.Variable)
+            : base("Obsolete", AnnotationTarget.Member | AnnotationTarget.Variable, allowedArguments: 1)
         {}
 
         public override IReadOnlyList<string> ProcessAnnotationArguments(IEnumerable<string> arguments)