Bring in refs WIP

Rubberduck.CodeAnalysis/Inspections/Concrete/IllegalAnnotationInspection.cs

@@ -20,18 +20,12 @@ public IllegalAnnotationInspection(RubberduckParserState state)
 
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
-            var illegalAnnotations = new List<IAnnotation>();
-
             var userDeclarations = State.DeclarationFinder.AllUserDeclarations.ToList();
             var identifierReferences = State.DeclarationFinder.AllIdentifierReferences().ToList();
             var annotations = State.AllAnnotations;
 
-            illegalAnnotations.AddRange(UnboundAnnotations(annotations, userDeclarations, identifierReferences));
-            illegalAnnotations.AddRange(NonIdentifierAnnotationsOnIdentifiers(identifierReferences));
-            illegalAnnotations.AddRange(NonModuleAnnotationsOnModules(userDeclarations));
-            illegalAnnotations.AddRange(NonMemberAnnotationsOnMembers(userDeclarations));
-            illegalAnnotations.AddRange(NonVariableAnnotationsOnVariables(userDeclarations));
-            illegalAnnotations.AddRange(NonGeneralAnnotationsWhereOnlyGeneralAnnotationsBelong(userDeclarations));
+            var illegalAnnotations = UnboundAnnotations(annotations, userDeclarations, identifierReferences)
+                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.GeneralAnnotation));
 
             return illegalAnnotations.Select(annotation => 
                 new QualifiedContextInspectionResult(
@@ -50,64 +44,5 @@ private static ICollection<IAnnotation> UnboundAnnotations(IEnumerable<IAnnotati
 
             return annotations.Where(annotation => !boundAnnotationsSelections.Contains(annotation.QualifiedSelection)).ToList();
         }
-
-        private static ICollection<IAnnotation> NonIdentifierAnnotationsOnIdentifiers(IEnumerable<IdentifierReference> identifierReferences)
-        {
-            return identifierReferences
-                .SelectMany(reference => reference.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.IdentifierAnnotation))
-                .ToList();
-        }
-
-        private static ICollection<IAnnotation> NonModuleAnnotationsOnModules(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => declaration.DeclarationType.HasFlag(DeclarationType.Module))
-                .SelectMany(moduleDeclaration => moduleDeclaration.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.ModuleAnnotation))
-                .ToList();
-        }
-
-        private static ICollection<IAnnotation> NonMemberAnnotationsOnMembers(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => declaration.DeclarationType.HasFlag(DeclarationType.Member))
-                .SelectMany(member => member.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.MemberAnnotation))
-                .ToList();
-        }
-
-        private static ICollection<IAnnotation> NonVariableAnnotationsOnVariables(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => VariableAnnotationDeclarationTypes.Contains(declaration.DeclarationType))
-                .SelectMany(declaration => declaration.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.VariableAnnotation))
-                .ToList();
-        }
-
-        private static readonly HashSet<DeclarationType> VariableAnnotationDeclarationTypes = new HashSet<DeclarationType>()
-        {
-            DeclarationType.Variable,
-            DeclarationType.Control,
-            DeclarationType.Constant,
-            DeclarationType.Enumeration,
-            DeclarationType.EnumerationMember,
-            DeclarationType.UserDefinedType,
-            DeclarationType.UserDefinedType,
-            DeclarationType.UserDefinedTypeMember
-        };
-
-        private static ICollection<IAnnotation> NonGeneralAnnotationsWhereOnlyGeneralAnnotationsBelong(IEnumerable<Declaration> userDeclarations)
-        {
-            return userDeclarations
-                .Where(declaration => !declaration.DeclarationType.HasFlag(DeclarationType.Module) 
-                                      && !declaration.DeclarationType.HasFlag(DeclarationType.Member) 
-                                      && !VariableAnnotationDeclarationTypes.Contains(declaration.DeclarationType) 
-                                      && declaration.DeclarationType != DeclarationType.Project)
-                .SelectMany(member => member.Annotations)
-                .Where(annotation => !annotation.AnnotationType.HasFlag(AnnotationType.GeneralAnnotation))
-                .ToList();
-        }
     }
 }

Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs

@@ -1,15 +1,17 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
 using Antlr4.Runtime.Tree;
 using Rubberduck.Inspections.Abstract;
+using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.Parsing;
 
 namespace Rubberduck.Inspections.QuickFixes
 {
@@ -29,98 +31,109 @@ public IgnoreOnceQuickFix(RubberduckParserState state, IEnumerable<IInspection>
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var annotationText = $"'@Ignore {result.Inspection.AnnotationName}";
-
-            int annotationLine;
-            //TODO: Make this use the parse tree instead of the code module.
-            var component = _state.ProjectsProvider.Component(result.QualifiedSelection.QualifiedName);
-            using (var module = component.CodeModule)
+            if (result.Target?.DeclarationType.HasFlag(DeclarationType.Module) ?? false)
             {
-                annotationLine = result.QualifiedSelection.Selection.StartLine;
-                while (annotationLine != 1 && module.GetLines(annotationLine - 1, 1).EndsWith(" _"))
-                {
-                    annotationLine--;
-                }
+                FixModule(result, rewriteSession);
             }
-
-            RuleContext treeRoot = result.Context;
-            while (treeRoot.Parent != null)
+            else
             {
-                treeRoot = treeRoot.Parent;
+                FixNonModule(result, rewriteSession);
             }
+        }
 
-            var listener = new CommentOrAnnotationListener();
-            ParseTreeWalker.Default.Walk(listener, treeRoot);
-            var commentContext = listener.Contexts.LastOrDefault(i => i.Stop.TokenIndex <= result.Context.Start.TokenIndex);
-            var commented = commentContext?.Stop.Line + 1 == annotationLine;
+        private void FixNonModule(IInspectionResult result, IRewriteSession rewriteSession)
+        {
+            int insertionIndex;
+            string insertText;
+            var annotationText = $"'@Ignore {result.Inspection.AnnotationName}";
 
-            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);
+            var module = result.QualifiedSelection.QualifiedName;
+            var parseTree = _state.GetParseTree(module, CodeKind.CodePaneCode);
+            var eolListener = new EndOfLineListener();
+            ParseTreeWalker.Default.Walk(eolListener, parseTree);
+            var previousEol = eolListener.Contexts
+                .OrderBy(eol => eol.Start.TokenIndex)
+                .LastOrDefault(eol => eol.Start.Line < result.QualifiedSelection.Selection.StartLine);
 
-            if (commented)
+            var rewriter = rewriteSession.CheckOutModuleRewriter(module);
+
+            if (previousEol == null)
             {
-                var annotation = commentContext.annotationList()?.annotation(0);
-                if (annotation != null && annotation.GetText().StartsWith("Ignore"))
-                {
-                    rewriter.InsertAfter(annotation.annotationName().Stop.TokenIndex, $" {result.Inspection.AnnotationName},");
-                }
-                else
-                {
-                    var indent = new string(Enumerable.Repeat(' ', commentContext.Start.Column).ToArray());
-                    rewriter.InsertAfter(commentContext.Stop.TokenIndex, $"{indent}{annotationText}{Environment.NewLine}");
-                }
+                // The context to get annotated is on the first line; we need to insert before token index 0.
+                insertionIndex = 0;
+                insertText = annotationText + Environment.NewLine;
+                rewriter.InsertBefore(insertionIndex, insertText);
+                return;
             }
-            else
+
+            var commentContext = previousEol.commentOrAnnotation();
+            if (commentContext == null)
+            {
+                insertionIndex = previousEol.Start.TokenIndex;
+                var indent = WhitespaceAfter(previousEol);
+                insertText = $"{Environment.NewLine}{indent}{annotationText}";
+                rewriter.InsertBefore(insertionIndex, insertText);
+                return;
+            }
+
+            var ignoreAnnotation = commentContext.annotationList()?.annotation()
+                .FirstOrDefault(annotationContext => annotationContext.annotationName().GetText() == AnnotationType.Ignore.ToString());
+            if (ignoreAnnotation == null)
             {
-                int insertIndex;
-
-                // this value is used when the annotation should be on line 1--we need to insert before token index 0
-                if (annotationLine == 1)
-                {
-                    insertIndex = 0;
-                    annotationText += Environment.NewLine;
-                }
-                else
-                {
-                    var eol = new EndOfLineListener();
-                    ParseTreeWalker.Default.Walk(eol, treeRoot);
-
-                    // we subtract 2 here to get the insertion index to A) account for VBE's one-based indexing
-                    // and B) to get the newline token that introduces that line
-                    var eolContext = eol.Contexts.OrderBy(o => o.Start.TokenIndex).ElementAt(annotationLine - 2);
-                    insertIndex = eolContext.Start.TokenIndex;
-
-                    annotationText = Environment.NewLine + annotationText;
-                }
-
-                rewriter.InsertBefore(insertIndex, annotationText);
+                insertionIndex = commentContext.Stop.TokenIndex;
+                var indent = WhitespaceAfter(previousEol);
+                insertText = $"{indent}{annotationText}{Environment.NewLine}";
+                rewriter.InsertAfter(insertionIndex, insertText);
+                return;
             }
+
+            insertionIndex = ignoreAnnotation.annotationName().Stop.TokenIndex;
+            insertText = $" {result.Inspection.AnnotationName},";
+            rewriter.InsertAfter(insertionIndex, insertText);
         }
 
-        public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.IgnoreOnce;
+        private static string WhitespaceAfter(VBAParser.EndOfLineContext endOfLine)
+        {
+            var individualEndOfStatement = (VBAParser.IndividualNonEOFEndOfStatementContext) endOfLine.Parent;
+            var whiteSpaceOnNextLine = individualEndOfStatement.whiteSpace(0);
+            return whiteSpaceOnNextLine != null
+                ? whiteSpaceOnNextLine.GetText()
+                : string.Empty;
+        }
 
-        private class CommentOrAnnotationListener : VBAParserBaseListener
+        private void FixModule(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            private readonly IList<VBAParser.CommentOrAnnotationContext> _contexts = new List<VBAParser.CommentOrAnnotationContext>();
-            public IEnumerable<VBAParser.CommentOrAnnotationContext> Contexts => _contexts;
+            var module = result.QualifiedSelection.QualifiedName;
+            var moduleAnnotations = _state.GetModuleAnnotations(module);
+            var firstIgnoreModuleAnnotation = moduleAnnotations
+                .Where(annotation => annotation.AnnotationType == AnnotationType.IgnoreModule)
+                .OrderBy(annotation => annotation.Context.Start.TokenIndex)
+                .FirstOrDefault();
 
-            public override void ExitCommentOrAnnotation([NotNull] VBAParser.CommentOrAnnotationContext context)
+            var rewriter = rewriteSession.CheckOutModuleRewriter(module);
+
+            int insertionIndex;
+            string insertText;
+
+            if (firstIgnoreModuleAnnotation == null)
             {
-                _contexts.Add(context);
+                insertionIndex = 0;
+                insertText = $"'@IgnoreModule {result.Inspection.AnnotationName}{Environment.NewLine}";
+                rewriter.InsertBefore(insertionIndex, insertText);
+                return;
             }
+
+            insertionIndex = firstIgnoreModuleAnnotation.Context.annotationName().Stop.TokenIndex;
+            insertText = $" {result.Inspection.AnnotationName},";
+            rewriter.InsertAfter(insertionIndex, insertText);
         }
 
+        public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.IgnoreOnce;
+
         private class EndOfLineListener : VBAParserBaseListener
         {
-            private readonly IList<ParserRuleContext> _contexts = new List<ParserRuleContext>();
-            public IEnumerable<ParserRuleContext> Contexts => _contexts;
-
-            public override void ExitWhiteSpace([NotNull] VBAParser.WhiteSpaceContext context)
-            {
-                if (context.GetText().Contains(Environment.NewLine))
-                {
-                    _contexts.Add(context);
-                }
-            }
+            private readonly IList<VBAParser.EndOfLineContext> _contexts = new List<VBAParser.EndOfLineContext>();
+            public IEnumerable<VBAParser.EndOfLineContext> Contexts => _contexts;
 
             public override void ExitEndOfLine([NotNull] VBAParser.EndOfLineContext context)
             {

Rubberduck.Core/AddRemoveReferences/IReferenceInfo.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Rubberduck.AddRemoveReferences
+{
+    public interface IReferenceInfo
+    {
+        Guid Guid { get; }
+        string Name { get; }
+        string FullPath { get; }
+        int Major { get; }
+        int Minor { get; }
+        int? Priority { get; }
+    }
+}