On local error inspection

Hosch250 · Hosch250 · commit b814ceed2ee5 · 2018-10-08T16:55:41.000-05:00
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/OnLocalErrorInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/OnLocalErrorInspection.cs
@@ -0,0 +1,54 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.VBEditor;
+using Antlr4.Runtime.Misc;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    public sealed class OnLocalErrorInspection : ParseTreeInspectionBase
+    {
+        public OnLocalErrorInspection(RubberduckParserState state)
+            : base(state) { }
+
+        public override IInspectionListener Listener { get; } =
+            new OnLocalErrorListener();
+
+        protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
+        {
+            return Listener.Contexts
+                .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line))
+                .Select(result => new QualifiedContextInspectionResult(this,
+                                                       InspectionResults.OnLocalErrorInspection,
+                                                       result));
+        }
+
+        public class OnLocalErrorListener : VBAParserBaseListener, IInspectionListener
+        {
+            private readonly List<QualifiedContext<ParserRuleContext>> _contexts = new List<QualifiedContext<ParserRuleContext>>();
+            public IReadOnlyList<QualifiedContext<ParserRuleContext>> Contexts => _contexts;
+            
+            public QualifiedModuleName CurrentModuleName { get; set; }
+
+            public void ClearContexts()
+            {
+                _contexts.Clear();
+            }
+
+            public override void ExitOnErrorStmt([NotNull] VBAParser.OnErrorStmtContext context)
+            {
+                if (context.ON_LOCAL_ERROR() != null)
+                {
+                    _contexts.Add(new QualifiedContext<ParserRuleContext>(CurrentModuleName, context));
+                }
+            }
+        }
+    }
+}
diff --git a/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj b/Rubberduck.CodeAnalysis/Rubberduck.CodeAnalysis.csproj
@@ -81,6 +81,7 @@
     <Compile Include="Inspections\Concrete\EmptyForEachBlockInspection.cs" />
     <Compile Include="Inspections\Concrete\EmptyForLoopBlockInspection.cs" />
     <Compile Include="Inspections\Concrete\BooleanAssignedInIfElseInspection.cs" />
+    <Compile Include="Inspections\Concrete\OnLocalErrorInspection.cs" />
     <Compile Include="Inspections\Concrete\ModuleWithoutFolderInspection.cs" />
     <Compile Include="Inspections\Concrete\EmptyWhileWendBlockInspection.cs" />
     <Compile Include="Inspections\Concrete\ObsoleteCallingConventionInspection.cs" />
diff --git a/Rubberduck.Core/Properties/Settings.Designer.cs b/Rubberduck.Core/Properties/Settings.Designer.cs
diff --git a/Rubberduck.Core/Properties/Settings.settings b/Rubberduck.Core/Properties/Settings.settings
@@ -280,6 +280,7 @@
     &lt;CodeInspection Name="ObsoleteCallingConventionInspection" Severity="Warning" InspectionType="CodeQualityIssues" /&gt;
     &lt;CodeInspection Name="DuplicatedAnnotationInspection" Severity="Error" InspectionType="RubberduckOpportunities" /&gt;
     &lt;CodeInspection Name="ModuleWithoutFolderInspection" Severity="Suggestion" InspectionType="RubberduckOpportunities" /&gt;
+    &lt;CodeInspection Name="OnLocalErrorInspection" Severity="Suggestion" InspectionType="RubberduckOpportunities" /&gt;
   &lt;/CodeInspections&gt;
   &lt;WhitelistedIdentifiers /&gt;
   &lt;RunInspectionsOnSuccessfulParse&gt;true&lt;/RunInspectionsOnSuccessfulParse&gt;
diff --git a/Rubberduck.Core/app.config b/Rubberduck.Core/app.config
@@ -404,6 +404,8 @@
                 InspectionType="RubberduckOpportunities" />
               <CodeInspection Name="ModuleWithoutFolderInspection" Severity="Suggestion"
                 InspectionType="RubberduckOpportunities" />
+              <CodeInspection Name="OnLocalErrorInspection" Severity="Suggestion"
+                InspectionType="RubberduckOpportunities" />
             </CodeInspections>
             <WhitelistedIdentifiers />
             <RunInspectionsOnSuccessfulParse>true</RunInspectionsOnSuccessfulParse>
diff --git a/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs b/Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs
diff --git a/Rubberduck.Resources/Inspections/InspectionInfo.resx b/Rubberduck.Resources/Inspections/InspectionInfo.resx
@@ -337,4 +337,7 @@ If the parameter can be null, ignore this inspection result; passing a null valu
   <data name="ModuleWithoutFolderInspection" xml:space="preserve">
     <value>Modules without the '@Folder' annotation cannot receive custom groupings in the Code Explorer. </value>
   </data>
+  <data name="OnLocalErrorInspection" xml:space="preserve">
+    <value>On Local Error exists only for compatibility with previous versions of Visual Basic, and all Errors are treated as Local regardless of the Error statement. Use of this keyword inaccurately gives the impression that there is a distinction between types of error handling when there is not.</value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs b/Rubberduck.Resources/Inspections/InspectionNames.Designer.cs
diff --git a/Rubberduck.Resources/Inspections/InspectionNames.resx b/Rubberduck.Resources/Inspections/InspectionNames.resx
@@ -336,4 +336,7 @@
   <data name="ModuleWithoutFolderInspection" xml:space="preserve">
     <value>Module without '@Folder' annotation</value>
   </data>
+  <data name="OnLocalErrorInspection" xml:space="preserve">
+    <value>On Local Error statement</value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs b/Rubberduck.Resources/Inspections/InspectionResults.Designer.cs
diff --git a/Rubberduck.Resources/Inspections/InspectionResults.resx b/Rubberduck.Resources/Inspections/InspectionResults.resx
@@ -366,4 +366,7 @@
   <data name="ModuleWithoutFolderInspection" xml:space="preserve">
     <value>Module '{0}' has no '@Folder' annotation</value>
   </data>
+  <data name="OnLocalErrorInspection" xml:space="preserve">
+    <value>'On Local Error' statement detected.</value>
+  </data>
 </root>
diff --git a/RubberduckTests/Inspections/OnLocalErrorInspectionTests.cs b/RubberduckTests/Inspections/OnLocalErrorInspectionTests.cs
@@ -0,0 +1,108 @@
+﻿using NUnit.Framework;
+using Rubberduck.Inspections.Concrete;
+using RubberduckTests.Mocks;
+using System.Linq;
+using System.Threading;
+
+namespace RubberduckTests.Inspections
+{
+    [TestFixture]
+    public class OnLocalErrorInspectionTests
+    {
+        [Test]
+        [Category("Inspections")]
+        public void OnLocalError_Goto0_ReturnsResult()
+        {
+            const string inputCode =
+                @"Sub foo()
+    on local error goto 0
+End Sub";
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new OnLocalErrorInspection(state);
+                var inspector = InspectionsHelper.GetInspector(inspection);
+                var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void OnLocalError_ResumeNext_ReturnsResult()
+        {
+            const string inputCode =
+                @"Sub foo()
+    on local error resume next
+End Sub";
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new OnLocalErrorInspection(state);
+                var inspector = InspectionsHelper.GetInspector(inspection);
+                var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void OnLocalError_GotoLabel_ReturnsResult()
+        {
+            const string inputCode =
+                @"Sub foo()
+    On Local Error GoTo Label
+Label:
+End Sub";
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new OnLocalErrorInspection(state);
+                var inspector = InspectionsHelper.GetInspector(inspection);
+                var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void OnLocalError_Goto1_ReturnsResult()
+        {
+            const string inputCode =
+                @"Sub foo()
+    on local error goto 1
+End Sub";
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new OnLocalErrorInspection(state);
+                var inspector = InspectionsHelper.GetInspector(inspection);
+                var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void OnError_Goto0_DoesNotReturnResult()
+        {
+            const string inputCode =
+                @"Sub foo()
+    on error goto 0
+End Sub";
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new OnLocalErrorInspection(state);
+                var inspector = InspectionsHelper.GetInspector(inspection);
+                var inspectionResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+
+                Assert.AreEqual(0, inspectionResults.Count());
+            }
+        }
+    }
+}
diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj
@@ -111,6 +111,7 @@
     <Compile Include="CodeExplorer\CodeExplorerTests.cs" />
     <Compile Include="Inspections\ImplicitDefaultMemberAssignmentInspectionTests.cs" />
     <Compile Include="Inspections\ModuleWithoutFolderInspectionTests.cs" />
+    <Compile Include="Inspections\OnLocalErrorInspectionTests.cs" />
     <Compile Include="Inspections\UnreachableCase\ExpressionFilterUnitTests.cs" />
     <Compile Include="Inspections\UnreachableCase\ParseTreeExpressionEvaluatorUnitTests.cs" />
     <Compile Include="Inspections\UnreachableCase\ParseTreeValueUnitTests.cs" />
