Redesign Annotation Processing

This redesigns annotation processing to no longer rely on the AnnotationTypes enum to identify
an annotation, allowing us to separate the scoping of an annotation from it's type.

Additionally this explicitly stores metainformation on annotations in Attributes on the specific
annotation type. This metainformation is used to automatically register annotations for the
code pane parsing process.

These changes have far-reaching implications for how annotations are used, most of them addressed
in this commit. The parsing of annotations through the VBA API is not correctly dealt with.

Author: Vogel612

Rubberduck.API/VBA/Parser.cs

@@ -25,6 +25,7 @@
 using Rubberduck.Root;
 using Rubberduck.VBEditor.ComManagement.TypeLibs;
 using Rubberduck.VBEditor.SourceCodeHandling;
+using Rubberduck.Parsing.Annotations;
 
 namespace Rubberduck.API.VBA
 {
@@ -106,6 +107,8 @@ internal Parser(object vbe) : this()
             var preprocessorErrorListenerFactory = new PreprocessingParseErrorListenerFactory();
             var preprocessorParser = new VBAPreprocessorParser(preprocessorErrorListenerFactory, preprocessorErrorListenerFactory);
             var preprocessor = new VBAPreprocessor(preprocessorParser, compilationsArgumentsCache);
+            // FIXME inject annotation types to allow Rubberduck api users to access Annotations from VBA code
+            var annotationProcessor = new VBAParserAnnotationFactory(new List<Type>());
             var mainParseErrorListenerFactory = new MainParseErrorListenerFactory();
             var mainTokenStreamParser = new VBATokenStreamParser(mainParseErrorListenerFactory, mainParseErrorListenerFactory);
             var tokenStreamProvider = new SimpleVBAModuleTokenStreamProvider();
@@ -139,7 +142,8 @@ internal Parser(object vbe) : this()
             var moduleParser = new ModuleParser(
                 codePaneSourceCodeHandler,
                 attributesSourceCodeHandler,
-                stringParser);
+                stringParser,
+                annotationProcessor);
             var parseRunner = new ParseRunner(
                 _state,
                 parserStateManager,

Rubberduck.CodeAnalysis/Inspections/Concrete/AttributeValueOutOfSyncInspection.cs

@@ -49,7 +49,7 @@ public AttributeValueOutOfSyncInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var declarationsWithAttributeAnnotations = State.DeclarationFinder.AllUserDeclarations
-                .Where(declaration => declaration.Annotations.Any(annotation => annotation.AnnotationType.HasFlag(AnnotationType.Attribute)));
+                .Where(declaration => declaration.Annotations.Any(annotation => annotation is IAttributeAnnotation));
             var results = new List<DeclarationInspectionResult>();
             foreach (var declaration in declarationsWithAttributeAnnotations.Where(decl => decl.QualifiedModuleName.ComponentType != ComponentType.Document))
             {

Rubberduck.CodeAnalysis/Inspections/Concrete/DuplicatedAnnotationInspection.cs

@@ -46,8 +46,8 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             foreach (var declaration in State.AllUserDeclarations)
             {
                 var duplicateAnnotations = declaration.Annotations
-                    .GroupBy(annotation => annotation.AnnotationType)
-                    .Where(group => !group.First().AllowMultiple && group.Count() > 1);
+                    .GroupBy(annotation => annotation.GetType())
+                    .Where(group => !group.First().MetaInformation.AllowMultiple && group.Count() > 1);
 
                 issues.AddRange(duplicateAnnotations.Select(duplicate =>
                 {

Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs

@@ -52,7 +52,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var annotations = State.AllAnnotations;
 
             var unboundAnnotations = UnboundAnnotations(annotations, userDeclarations, identifierReferences)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.GeneralAnnotation)
+                .Where(annotation => !annotation.MetaInformation.Target.HasFlag(AnnotationTarget.General)
                                      || annotation.AnnotatedLine == null);
             var attributeAnnotationsInDocuments = AttributeAnnotationsInDocuments(userDeclarations);
 

Rubberduck.CodeAnalysis/Inspections/Concrete/MissingAnnotationArgumentInspection.cs

@@ -48,10 +48,12 @@ public MissingAnnotationArgumentInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
+            // 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
             return (from result in Listener.Contexts
                     let context = (VBAParser.AnnotationContext)result.Context 
-                    where context.annotationName().GetText() == AnnotationType.Ignore.ToString() 
-                       || context.annotationName().GetText() == AnnotationType.Folder.ToString() 
+                    where context.annotationName().GetText() == "Ignore"
+                       || context.annotationName().GetText() == "Folder" 
                     where context.annotationArgList() == null 
                     select new QualifiedContextInspectionResult(this,
                                                 string.Format(InspectionResults.MissingAnnotationArgumentInspection,

Rubberduck.CodeAnalysis/Inspections/Concrete/MissingAttributeInspection.cs

@@ -48,7 +48,7 @@ public MissingAttributeInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var declarationsWithAttributeAnnotations = State.DeclarationFinder.AllUserDeclarations
-                .Where(declaration => declaration.Annotations.Any(annotation => annotation.AnnotationType.HasFlag(AnnotationType.Attribute)));
+                .Where(declaration => declaration.Annotations.Any(annotation => annotation is IAttributeAnnotation));
             var results = new List<DeclarationInspectionResult>();
             foreach (var declaration in declarationsWithAttributeAnnotations.Where(decl => decl.QualifiedModuleName.ComponentType != ComponentType.Document
                                                                                                    && !decl.IsIgnoringInspectionResultFor(AnnotationName)))

Rubberduck.CodeAnalysis/Inspections/Concrete/ModuleWithoutFolderInspection.cs

@@ -39,7 +39,7 @@ public ModuleWithoutFolderInspection(RubberduckParserState state)
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var modulesWithoutFolderAnnotation = State.DeclarationFinder.UserDeclarations(Parsing.Symbols.DeclarationType.Module)
-                .Where(w => w.Annotations.All(a => a.AnnotationType != AnnotationType.Folder))
+                .Where(w => !w.Annotations.OfType<FolderAnnotation>().Any())
                 .ToList();
 
             return modulesWithoutFolderAnnotation

Rubberduck.CodeAnalysis/Inspections/Concrete/ObsoleteMemberUsageInspection.cs

@@ -58,15 +58,13 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var declarations = State.AllUserDeclarations
                 .Where(declaration => declaration.DeclarationType.HasFlag(DeclarationType.Member) &&
-                                      declaration.Annotations.Any(annotation =>annotation.AnnotationType == AnnotationType.Obsolete));
+                                      declaration.Annotations.OfType<ObsoleteAnnotation>().Any());
 
             var issues = new List<IdentifierReferenceInspectionResult>();
 
             foreach (var declaration in declarations)
             {
-                var replacementDocumentation =
-                ((ObsoleteAnnotation) declaration.Annotations.First(annotation =>
-                    annotation.AnnotationType == AnnotationType.Obsolete)).ReplacementDocumentation;
+                var replacementDocumentation = declaration.Annotations.OfType<ObsoleteAnnotation>().First().ReplacementDocumentation;
 
                 issues.AddRange(declaration.References.Select(reference =>
                     new IdentifierReferenceInspectionResult(this,

Rubberduck.CodeAnalysis/QuickFixes/AdjustAttributeAnnotationQuickFix.cs

@@ -39,15 +39,15 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
                 }
                 else
                 {
-                    var (newAnnotationType, newAnnotationValues) = _attributeAnnotationProvider.ModuleAttributeAnnotation(attributeName, attributeValues);
-                    _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotationType, newAnnotationValues);
+                    var (newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.ModuleAttributeAnnotation(attributeName, attributeValues);
+                    _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotation, newAnnotationValues);
                 }
             }
             else
             {
                 var attributeBaseName = AttributeBaseName(attributeName, declaration);
-                var (newAnnotationType, newAnnotationValues) = _attributeAnnotationProvider.MemberAttributeAnnotation(attributeBaseName, attributeValues);
-                _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotationType, newAnnotationValues);
+                var (newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.MemberAttributeAnnotation(attributeBaseName, attributeValues);
+                _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotation, newAnnotationValues);
             }
         }
 

Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs

@@ -52,17 +52,17 @@ private void FixNonModule(IInspectionResult result, IRewriteSession rewriteSessi
                 .OfType<IgnoreAnnotation>()
                 .FirstOrDefault();
 
-            var annotationType = AnnotationType.Ignore;
+            var annotationInfo = typeof(IgnoreAnnotation).GetCustomAttributes(false).OfType<AnnotationAttribute>().Single();
             if (existingIgnoreAnnotation != null)
             {
                 var annotationValues = existingIgnoreAnnotation.InspectionNames.ToList();
                 annotationValues.Insert(0, result.Inspection.AnnotationName);
-                _annotationUpdater.UpdateAnnotation(rewriteSession, existingIgnoreAnnotation, annotationType, annotationValues);
+                _annotationUpdater.UpdateAnnotation(rewriteSession, existingIgnoreAnnotation, annotationInfo, annotationValues);
             }
             else
             {
                 var annotationValues = new List<string> { result.Inspection.AnnotationName };
-                _annotationUpdater.AddAnnotation(rewriteSession, new QualifiedContext(module, result.Context), annotationType, annotationValues);
+                _annotationUpdater.AddAnnotation(rewriteSession, new QualifiedContext(module, result.Context), annotationInfo, annotationValues);
             }
         }
 
@@ -73,7 +73,7 @@ private void FixModule(IInspectionResult result, IRewriteSession rewriteSession)
                 .OfType<IgnoreModuleAnnotation>()
                 .FirstOrDefault();
 
-            var annotationType = AnnotationType.IgnoreModule;
+            var annotationType = typeof(IgnoreModuleAnnotation).GetCustomAttributes(false).OfType<AnnotationAttribute>().Single();
             if (existingIgnoreModuleAnnotation != null)
             {
                 var annotationValues = existingIgnoreModuleAnnotation.InspectionNames.ToList();