implement annotations using the split parser/lexer (#1116)

Author: Andrin Meier

Rubberduck.Parsing/Annotations/AnnotationBase.cs

@@ -0,0 +1,49 @@
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public abstract class AnnotationBase : IAnnotation
+    {
+        private readonly VBAParser.AnnotationContext _context;
+        private readonly AnnotationType _annotationType;
+        private readonly AnnotationTargetType _targetType;
+
+        public const string ANNOTATION_MARKER = "'@";
+
+        public AnnotationBase(VBAParser.AnnotationContext context, AnnotationType annotationType, AnnotationTargetType targetType)
+        {
+            _context = context;
+            _annotationType = annotationType;
+            _targetType = targetType;
+        }
+
+        public VBAParser.AnnotationContext Context
+        {
+            get
+            {
+                return _context;
+            }
+        }
+
+        public AnnotationType AnnotationType
+        {
+            get
+            {
+                return _annotationType;
+            }
+        }
+
+        public AnnotationTargetType TargetType
+        {
+            get
+            {
+                return _targetType;
+            }
+        }
+
+        public override string ToString()
+        {
+            return string.Format("Annotation Type: {0}. TargetType: {1}.", _annotationType, _targetType);
+        }
+    }
+}

Rubberduck.Parsing/Annotations/AnnotationListener.cs

@@ -0,0 +1,32 @@
+using Antlr4.Runtime.Misc;
+using Rubberduck.Parsing.Grammar;
+using System.Collections.Generic;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public sealed class AnnotationListener : VBAParserBaseListener
+    {
+        private readonly List<IAnnotation> _annotations;
+        private readonly IAnnotationFactory _factory;
+
+        public AnnotationListener(IAnnotationFactory factory)
+        {
+            _annotations = new List<IAnnotation>();
+            _factory = factory;
+        }
+
+        public IEnumerable<IAnnotation> Annotations
+        {
+            get
+            {
+                return _annotations;
+            }
+        }
+
+        public override void ExitAnnotation([NotNull] VBAParser.AnnotationContext context)
+        {
+            var newAnnotation = _factory.Create(context, AnnotationTargetType.Unknown);
+            _annotations.Add(newAnnotation);
+        }
+    }
+}

Rubberduck.Parsing/Annotations/AnnotationTargetType.cs

@@ -0,0 +1,10 @@
+namespace Rubberduck.Parsing.Annotations
+{
+    public enum AnnotationTargetType
+    {
+        Unknown,
+        Module,
+        Method,
+        VariableStatement
+    }
+}

Rubberduck.Parsing/Annotations/AnnotationType.cs

@@ -0,0 +1,14 @@
+namespace Rubberduck.Parsing.Annotations
+{
+    public enum AnnotationType
+    {
+        TestModule,
+        ModuleInitialize,
+        ModuleCleanup,
+        TestMethod,
+        TestInitialize,
+        TestCleanup,
+        Ignore,
+        Folder
+    }
+}

Rubberduck.Parsing/Annotations/FolderAnnotation.cs

@@ -0,0 +1,34 @@
+using Rubberduck.Parsing.Grammar;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public sealed class FolderAnnotation : AnnotationBase
+    {
+        private readonly string _folderName;
+
+        public FolderAnnotation(VBAParser.AnnotationContext context, AnnotationTargetType targetType, IEnumerable<string> parameters)
+            : base(context, AnnotationType.Folder, targetType)
+        {
+            if (parameters.Count() != 1)
+            {
+                throw new InvalidAnnotationArgumentException(string.Format("{0} expects exactly one argument, the folder, but none or more than one were passed.", this.GetType().Name));
+            }
+            _folderName = parameters.First();
+        }
+
+        public string FolderName
+        {
+            get
+            {
+                return _folderName;
+            }
+        }
+
+        public override string ToString()
+        {
+            return string.Format("Folder: {0}.", _folderName);
+        }
+    }
+}

Rubberduck.Parsing/Annotations/IAnnotation.cs

@@ -0,0 +1,11 @@
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public interface IAnnotation
+    {
+        AnnotationType AnnotationType { get; }
+        VBAParser.AnnotationContext Context { get; }
+        AnnotationTargetType TargetType { get; }
+    }
+}

Rubberduck.Parsing/Annotations/IAnnotationFactory.cs

@@ -0,0 +1,11 @@
+using Antlr4.Runtime;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public interface IAnnotationFactory
+    {
+        IAnnotation Create(VBAParser.AnnotationContext annotationContext, AnnotationTargetType targetType);
+    }
+}

Rubberduck.Parsing/Annotations/IgnoreAnnotation.cs

@@ -0,0 +1,39 @@
+using Rubberduck.Parsing.Grammar;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public sealed class IgnoreAnnotation : AnnotationBase
+    {
+        private readonly IEnumerable<string> _inspectionNames;
+
+        public IgnoreAnnotation(VBAParser.AnnotationContext context, AnnotationTargetType targetType, IEnumerable<string> parameters)
+            : base(context, AnnotationType.Ignore, targetType)
+        {
+            if (!parameters.Any())
+            {
+                throw new InvalidAnnotationArgumentException(string.Format("{0} expects at least one argument but none were given.", this.GetType().Name));
+            }
+            _inspectionNames = parameters.ToList();
+        }
+
+        public IEnumerable<string> InspectionNames
+        {
+            get
+            {
+                return _inspectionNames;
+            }
+        }
+
+        public bool IsIgnored(string inspectionName)
+        {
+            return _inspectionNames.Contains(inspectionName);
+        }
+
+        public override string ToString()
+        {
+            return string.Format("Ignored inspections: {0}.", string.Join(", ", _inspectionNames));
+        }
+    }
+}

Rubberduck.Parsing/Annotations/InvalidAnnotationArgumentException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    [Serializable]
+    public class InvalidAnnotationArgumentException : Exception
+    {
+        public InvalidAnnotationArgumentException(string message)
+            : base(message)
+        {
+        }
+    }
+}

Rubberduck.Parsing/Annotations/ModuleCleanupAnnotation.cs

@@ -0,0 +1,13 @@
+using Rubberduck.Parsing.Grammar;
+using System.Collections.Generic;
+
+namespace Rubberduck.Parsing.Annotations
+{
+    public sealed class ModuleCleanupAnnotation : AnnotationBase
+    {
+        public ModuleCleanupAnnotation(VBAParser.AnnotationContext context, AnnotationTargetType targetType, IEnumerable<string> parameters)
+            : base(context, AnnotationType.TestMethod, targetType)
+        {
+        }
+    }
+}