Make IgnoreOnceQuickfix able to handle modules

Previously, the fix silently expected to be handed an inspection result with a parser context. Module inspection results have none. Moreover it always used Ignore whereas modules require IgnoreModule.

Author: MDoerner

Rubberduck.CodeAnalysis/QuickFixes/IgnoreOnceQuickFix.cs

@@ -9,7 +9,9 @@
 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,32 +31,31 @@ public IgnoreOnceQuickFix(RubberduckParserState state, IEnumerable<IInspection>
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var annotationText = $"'@Ignore {result.Inspection.AnnotationName}";
+            var annotationText = result.Target?.DeclarationType.HasFlag(DeclarationType.Module) == true
+                                    ? $"'@IgnoreModule {result.Inspection.AnnotationName}"
+                                    : $"'@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)
+            using (var codeModule = component.CodeModule)
             {
                 annotationLine = result.QualifiedSelection.Selection.StartLine;
-                while (annotationLine != 1 && module.GetLines(annotationLine - 1, 1).EndsWith(" _"))
+                while (annotationLine != 1 && codeModule.GetLines(annotationLine - 1, 1).EndsWith(" _"))
                 {
                     annotationLine--;
                 }
             }
 
-            RuleContext treeRoot = result.Context;
-            while (treeRoot.Parent != null)
-            {
-                treeRoot = treeRoot.Parent;
-            }
+            var module = result.QualifiedSelection.QualifiedName;
+            var parseTree = _state.GetParseTree(module, CodeKind.CodePaneCode);
 
             var listener = new CommentOrAnnotationListener();
-            ParseTreeWalker.Default.Walk(listener, treeRoot);
+            ParseTreeWalker.Default.Walk(listener, parseTree);
             var commentContext = listener.Contexts.LastOrDefault(i => i.Stop.TokenIndex <= result.Context.Start.TokenIndex);
             var commented = commentContext?.Stop.Line + 1 == annotationLine;
 
-            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);
+            var rewriter = rewriteSession.CheckOutModuleRewriter(module);
 
             if (commented)
             {
@@ -82,7 +83,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
                 else
                 {
                     var eol = new EndOfLineListener();
-                    ParseTreeWalker.Default.Walk(eol, treeRoot);
+                    ParseTreeWalker.Default.Walk(eol, parseTree);
 
                     // 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

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -649,6 +649,16 @@ public void SetModuleComments(QualifiedModuleName module, IEnumerable<CommentNod
             _moduleStates[module].SetComments(new List<CommentNode>(comments));
         }
 
+        public IReadOnlyCollection<CommentNode> GetModuleComments(QualifiedModuleName module)
+        {
+            if (!_moduleStates.TryGetValue(module, out var moduleState))
+            {
+                return new List<CommentNode>();
+            }
+
+            return moduleState.Comments;
+        }
+
         public List<IAnnotation> AllAnnotations
         {
             get

RubberduckTests/QuickFixes/IgnoreOnceQuickFixTests.cs

@@ -830,6 +830,38 @@ Sub Foo(arg1)
             Assert.AreEqual(expectedCode, actualCode);
         }
 
+
+        [Test]
+        [Category("QuickFixes")]
+        public void EmptyModule_IgnoreQuickFixWorks()
+        {
+            const string inputCode =
+                @"Option Explicit";
+
+            const string expectedCode =
+                @"'@IgnoreModule EmptyModule
+Option Explicit";
+
+            var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new EmptyModuleInspection(state), TestStandardModuleVbeSetup);
+            Assert.AreEqual(expectedCode, actualCode);
+        }
+
+
+        [Test]
+        [Category("QuickFixes")]
+        public void ModuleWithoutFolder_IgnoreQuickFixWorks()
+        {
+            const string inputCode =
+                @"Option Explicit";
+
+            const string expectedCode =
+                @"'@IgnoreModule ModuleWithoutFolder
+Option Explicit";
+
+            var actualCode = ApplyIgnoreOnceToFirstResult(inputCode, state => new ModuleWithoutFolderInspection(state), TestStandardModuleVbeSetup);
+            Assert.AreEqual(expectedCode, actualCode);
+        }
+
         [Test]
         [Category("QuickFixes")]
         public void WriteOnlyProperty_IgnoreQuickFixWorks()