Tests for ignored inspections and ignore quick fix. A few bug fixes.

RetailCoder.VBE/Inspections/EmptyStringLiteralInspection.cs

@@ -1,9 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Antlr4.Runtime;
-using Microsoft.Vbe.Interop;
 using Rubberduck.Parsing;
-using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.Grammar;
 
@@ -29,33 +27,11 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                 return new InspectionResultBase[] { };
             }
             return ParseTreeResults.EmptyStringLiterals
-                .Where(s => !HasIgnoreEmptyStringLiteralAnnotations(s.ModuleName.Component, s.Context.Start.Line))
+                .Where(s => !HasIgnoreAnnotation(s.ModuleName.Component, s.Context.Start.Line))
                 .Select(context => new EmptyStringLiteralInspectionResult(this,
                             new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
         }
 
-        private bool HasIgnoreEmptyStringLiteralAnnotations(VBComponent component, int line)
-        {
-            var annotations = State.GetModuleAnnotations(component).ToList();
-
-            if (State.GetModuleAnnotations(component) == null)
-            {
-                return false;
-            }
-
-            // VBE 1-based indexing
-            for (var i = line - 1; i >= 1; i--)
-            {
-                var annotation = annotations.SingleOrDefault(a => a.QualifiedSelection.Selection.StartLine == i) as IgnoreAnnotation;
-                if (annotation != null && annotation.InspectionNames.Contains(AnnotationName))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
         public class EmptyStringLiteralListener : VBAParserBaseListener
         {
             private readonly IList<VBAParser.LiteralExpressionContext> _contexts = new List<VBAParser.LiteralExpressionContext>();

RetailCoder.VBE/Inspections/InspectionBase.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 
@@ -81,6 +83,28 @@ protected virtual IEnumerable<Declaration> BuiltInDeclarations
             get { return State.AllDeclarations.Where(declaration => declaration.IsBuiltIn); }
         }
 
+        protected bool HasIgnoreAnnotation(VBComponent component, int line)
+        {
+            var annotations = State.GetModuleAnnotations(component).ToList();
+
+            if (State.GetModuleAnnotations(component) == null)
+            {
+                return false;
+            }
+
+            // VBE 1-based indexing
+            for (var i = line - 1; i >= 1; i--)
+            {
+                var annotation = annotations.SingleOrDefault(a => a.QualifiedSelection.Selection.StartLine == i) as IgnoreAnnotation;
+                if (annotation != null && annotation.InspectionNames.Contains(AnnotationName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Gets all user declarations in the parser state without an @Ignore annotation for this inspection.
         /// </summary>

RetailCoder.VBE/Inspections/MultilineParameterInspectionResult.cs

@@ -15,7 +15,7 @@ public MultilineParameterInspectionResult(IInspection inspection, Declaration ta
             _quickFixes = new CodeInspectionQuickFix[]
             {
                 new MakeSingleLineParameterQuickFix(Context, QualifiedSelection),
-                new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName) 
+                new IgnoreOnceQuickFix(Target.ParentDeclaration.Context, Target.ParentDeclaration.QualifiedSelection, Inspection.AnnotationName) 
             };
         }
 

RetailCoder.VBE/Inspections/ObsoleteCallStatementInspection.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.VBA;
@@ -26,7 +27,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
 
             var results = new List<ObsoleteCallStatementUsageInspectionResult>();
 
-            foreach (var context in ParseTreeResults.ObsoleteCallContexts)
+            foreach (var context in ParseTreeResults.ObsoleteCallContexts.Where(o => !HasIgnoreAnnotation(o.ModuleName.Component, o.Context.Start.Line)))
             {
                 var lines = context.ModuleName.Component.CodeModule.Lines[
                         context.Context.Start.Line, context.Context.Stop.Line - context.Context.Start.Line + 1];

RetailCoder.VBE/Inspections/ObsoleteCommentSyntaxInspection.cs

@@ -21,7 +21,8 @@ public ObsoleteCommentSyntaxInspection(RubberduckParserState state)
 
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
-            return State.AllComments.Where(comment => comment.Marker == Tokens.Rem)
+            return State.AllComments.Where(comment => comment.Marker == Tokens.Rem &&
+                                            !HasIgnoreAnnotation(comment.QualifiedSelection.QualifiedName.Component, comment.QualifiedSelection.Selection.StartLine))
                 .Select(comment => new ObsoleteCommentSyntaxInspectionResult(this, comment));
         }
     }

RetailCoder.VBE/Inspections/ObsoleteLetStatementInspection.cs

@@ -25,8 +25,9 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
             {
                 return new InspectionResultBase[] { };
             }
-            return ParseTreeResults.ObsoleteLetContexts.Select(context =>
-                new ObsoleteLetStatementUsageInspectionResult(this, new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
+            return ParseTreeResults.ObsoleteLetContexts
+                .Where(o => !HasIgnoreAnnotation(o.ModuleName.Component, o.Context.Start.Line))
+                .Select(context => new ObsoleteLetStatementUsageInspectionResult(this, new QualifiedContext<ParserRuleContext>(context.ModuleName, context.Context)));
         }
 
         public class ObsoleteLetStatementListener : VBAParserBaseListener

RetailCoder.VBE/Inspections/UntypedFunctionUsageInspection.cs

@@ -48,7 +48,8 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                         item.Scope.StartsWith("VBE7.DLL;"));
 
             return declarations.SelectMany(declaration => declaration.References
-                .Where(item => _tokens.Contains(item.IdentifierName))
+                .Where(item => _tokens.Contains(item.IdentifierName) &&
+                               !HasIgnoreAnnotation(item.QualifiedModuleName.Component, item.Selection.StartLine))
                 .Select(item => new UntypedFunctionUsageInspectionResult(this, item)));
         }
     }

RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs

@@ -119,6 +119,33 @@ public void AssignedByValParameter_DoesNotReturnResult()
             Assert.AreEqual(0, inspectionResults.Count());
         }
 
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void AssignedByValParameter_Ignored_DoesNotReturnResult_Sub()
+        {
+            const string inputCode =
+@"'@Ignore AssignedByValParameter
+Public Sub Foo(ByVal arg1 As String)
+    Let arg1 = ""test""
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            VBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new AssignedByValParameterInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            Assert.IsFalse(inspectionResults.Any());
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void AssignedByValParameter_ReturnsResult_SomeAssignedByValParams()
@@ -183,6 +210,42 @@ public void AssignedByValParameter_QuickFixWorks()
             Assert.AreEqual(expectedCode, module.Lines());
         }
 
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void AssignedByValParameter_IgnoreQuickFixWorks()
+        {
+            const string inputCode =
+@"Public Sub Foo(ByVal arg1 As String)
+    Let arg1 = ""test""
+End Sub";
+
+            const string expectedCode =
+@"'@Ignore AssignedByValParameter
+Public Sub Foo(ByVal arg1 As String)
+    Let arg1 = ""test""
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            VBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var project = vbe.Object.VBProjects.Item(0);
+            var module = project.VBComponents.Item(0).CodeModule;
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new AssignedByValParameterInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix();
+
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void InspectionType()

RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs

@@ -70,12 +70,14 @@ public void ConstantNotUsed_ReturnsResult_MultipleConsts()
 
         [TestMethod]
         [TestCategory("Inspections")]
-        public void GivenReferencedConstant_ReturnsNoInspectionResult()
+        public void ConstantNotUsed_ReturnsResult_UnusedConstant()
         {
             const string inputCode =
 @"Public Sub Foo()
     Const const1 As Integer = 9
     Goo const1
+
+    Const const2 As String = ""test""
 End Sub
 
 Public Sub Goo(ByVal arg1 As Integer)
@@ -95,19 +97,17 @@ End Sub
             var inspection = new ConstantNotUsedInspection(parser.State);
             var inspectionResults = inspection.GetInspectionResults();
 
-            Assert.AreEqual(0, inspectionResults.Count());
+            Assert.AreEqual(1, inspectionResults.Count());
         }
 
         [TestMethod]
         [TestCategory("Inspections")]
-        public void GivenConstantNotUsed_ReturnsResultForUnusedConstant()
+        public void ConstantNotUsed_DoesNotReturnResult()
         {
             const string inputCode =
 @"Public Sub Foo()
     Const const1 As Integer = 9
     Goo const1
-
-    Const const2 As String = ""test""
 End Sub
 
 Public Sub Goo(ByVal arg1 As Integer)
@@ -127,7 +127,34 @@ End Sub
             var inspection = new ConstantNotUsedInspection(parser.State);
             var inspectionResults = inspection.GetInspectionResults();
 
-            Assert.AreEqual(1, inspectionResults.Count());
+            Assert.AreEqual(0, inspectionResults.Count());
+        }
+
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void ConstantNotUsed_Ignored_DoesNotReturnResult()
+        {
+            const string inputCode =
+@"Public Sub Foo()
+    '@Ignore ConstantNotUsed
+    Const const1 As Integer = 9
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            VBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new ConstantNotUsedInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            Assert.IsFalse(inspectionResults.Any());
         }
 
         [TestMethod]
@@ -164,6 +191,42 @@ public void ConstantNotUsed_QuickFixWorks()
             Assert.AreEqual(expectedCode, module.Lines());
         }
 
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void ConstantNotUsed_IgnoreQuickFixWorks()
+        {
+            const string inputCode =
+@"Public Sub Foo()
+    Const const1 As Integer = 9
+End Sub";
+
+            const string expectedCode =
+@"Public Sub Foo()
+'@Ignore ConstantNotUsed
+    Const const1 As Integer = 9
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            VBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var project = vbe.Object.VBProjects.Item(0);
+            var module = project.VBComponents.Item(0).CodeModule;
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new ConstantNotUsedInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix();
+
+            Assert.AreEqual(expectedCode, module.Lines());
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void InspectionType()

RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs

@@ -18,12 +18,10 @@ public class DefaultProjectNameInspectionTests
         [TestCategory("Inspections")]
         public void DefaultProjectName_ReturnsResult()
         {
-            const string inputCode = @"";
-
             //Arrange
             var builder = new MockVbeBuilder();
             var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
-                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
+                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, string.Empty)
                 .Build();
             var vbe = builder.AddProject(project).Build();
 
@@ -44,12 +42,10 @@ public void DefaultProjectName_ReturnsResult()
         [TestCategory("Inspections")]
         public void DefaultProjectName_DoesNotReturnResult()
         {
-            const string inputCode = @"";
-
             //Arrange
             var builder = new MockVbeBuilder();
             var project = builder.ProjectBuilder("TestProject", vbext_ProjectProtection.vbext_pp_none)
-                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
+                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, string.Empty)
                 .Build();
             var vbe = builder.AddProject(project).Build();
 
@@ -66,6 +62,30 @@ public void DefaultProjectName_DoesNotReturnResult()
             Assert.AreEqual(0, inspectionResults.Count());
         }
 
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void DefaultProjectName_NoIgnoreQuickFix()
+        {
+            //Arrange
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, string.Empty)
+                .Build();
+            var vbe = builder.AddProject(project).Build();
+
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object, new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new DefaultProjectNameInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            Assert.IsFalse(inspectionResults.ElementAt(0).QuickFixes.Any(q => q is IgnoreOnceQuickFix));
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void InspectionType()