Adds unit test for 4659 and 4680

Author: BZngr

Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/UnreachableCaseInspection.cs

@@ -51,13 +51,11 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             var qualifiedSelectCaseStmts = Listener.Contexts
                 .Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line));
 
-            var listener = (UnreachableCaseInspectionListener)Listener;
-            var parseTreeValueVisitor = CreateParseTreeValueVisitor(_valueFactory, listener.EnumerationStmtContexts.ToList(), GetIdentifierReferenceForContext);
-            parseTreeValueVisitor.OnValueResultCreated += ValueResults.OnNewValueResult;
+            ParseTreeValueVisitor.OnValueResultCreated += ValueResults.OnNewValueResult;
 
             foreach (var qualifiedSelectCaseStmt in qualifiedSelectCaseStmts)
             {
-                qualifiedSelectCaseStmt.Context.Accept(parseTreeValueVisitor);
+                qualifiedSelectCaseStmt.Context.Accept(ParseTreeValueVisitor);
                 var selectCaseInspector = _unreachableCaseInspectorFactory.Create((VBAParser.SelectCaseStmtContext)qualifiedSelectCaseStmt.Context, ValueResults, _valueFactory, GetVariableTypeName);
 
                 selectCaseInspector.InspectForUnreachableCases();
@@ -71,6 +69,20 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
             return _inspectionResults;
         }
 
+        private IParseTreeValueVisitor _parseTreeValueVisitor;
+        public IParseTreeValueVisitor ParseTreeValueVisitor
+        {
+            get
+            {
+                if (_parseTreeValueVisitor is null)
+                {
+                    var listener = (UnreachableCaseInspectionListener)Listener;
+                    _parseTreeValueVisitor = CreateParseTreeValueVisitor(_valueFactory, listener.EnumerationStmtContexts.ToList(), GetIdentifierReferenceForContext);
+                }
+                return _parseTreeValueVisitor;
+            }
+        }
+
         private void CreateInspectionResult(QualifiedContext<ParserRuleContext> selectStmt, ParserRuleContext unreachableBlock, string message)
         {
             var result = new QualifiedContextInspectionResult(this,
@@ -80,9 +92,7 @@ private void CreateInspectionResult(QualifiedContext<ParserRuleContext> selectSt
         }
 
         public static IParseTreeValueVisitor CreateParseTreeValueVisitor(IParseTreeValueFactory valueFactory, List<VBAParser.EnumerationStmtContext> allEnums, Func<ParserRuleContext, (bool success, IdentifierReference idRef)> func)
-        {
-            return new ParseTreeValueVisitor(valueFactory, allEnums, func);
-        }
+            => new ParseTreeValueVisitor(valueFactory, allEnums, func);
 
         //Method is used as a delegate to avoid propogating RubberduckParserState beyond this class
         private (bool success, IdentifierReference idRef) GetIdentifierReferenceForContext(ParserRuleContext context)

RubberduckTests/Inspections/UnreachableCase/UnreachableCaseInspectionTests.cs

@@ -3,8 +3,10 @@
 using Rubberduck.Inspections.Concrete.UnreachableCaseInspection;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.VBEditor.SafeComWrappers;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using RubberduckTests.Mocks;
 using System.Collections.Generic;
 using System.Linq;
@@ -1357,10 +1359,10 @@ End Select
             Assert.AreEqual(expectedMsg, actualMsg);
         }
 
-        //#4119
+        //https://github.com/rubberduck-vba/Rubberduck/issues/4119
         [Test]
         [Category("Inspections")]
-        public void UnreachableCaseInspection_EnumerationIssue4119Scenario()
+        public void UnreachableCaseInspection_Enumeration()
         {
             const string inputCode =
 @"
@@ -1801,7 +1803,6 @@ End Select
             Assert.AreEqual(expectedMsg, actualMsg);
         }
 
-        //Issue# 3885
         //this test only proves that the Select Statement is not inspected
         [Test]
         [Category("Inspections")]
@@ -1861,7 +1862,6 @@ End Select
             Assert.AreEqual(expectedMsg, actualMsg);
         }
 
-        //Issue# 3885 - replicates with UDT rather than a built-in
         [TestCase("Long")]
         [TestCase("Variant")]
         [Category("Inspections")]
@@ -2258,7 +2258,7 @@ End Select
             Assert.AreEqual(expectedMsg, actualMsg);
         }
 
-        //From Issue #3962
+        //https://github.com/rubberduck-vba/Rubberduck/issues/3962
         [Test]
         [Category("Inspections")]
         public void UnreachableCaseInspection_AdditionString()
@@ -2441,13 +2441,127 @@ End Sub
             Assert.AreEqual(expectedMsg, actualMsg);
         }
 
+        [TestCase("vbBack", "\b")]
+        [TestCase("vbCrLf", "\r\n")]
+        [TestCase("vbCr", "\r")]
+        [TestCase("vbLf", "\n")]
+        [TestCase("vbFormFeed", "\f")]
+        [TestCase("vbNewLine", "\r\n")]
+        [TestCase("vbNullChar", "\0")]
+        [TestCase("vbNullString", null)]
+        [TestCase("vbTab", "\t")]
+        [TestCase("vbVerticalTab", "\v")]
+        [Category("Inspections")]
+        public void UnreachableCaseInspection_VbStringConstantToLiteral_AreEqual(string constToken, string expected)
+        {
+            var parseTreeValueVisitor = new ParseTreeValueVisitor(null, new List<VBAParser.EnumerationStmtContext>(), null) as ITestParseTreeVisitor;
+            if (parseTreeValueVisitor.IsVBStringConstantToLiteral(constToken, out string literalValue))
+            {
+                Assert.AreEqual(expected, literalValue);
+                return;
+            }
+            Assert.Fail($"TryConvertVBStringConstantToLiteral failed to convert {constToken}");
+        }
+
+        [TestCase("\r", true)]
+        [TestCase("\r\n", true)]
+        [TestCase("\b", true)]
+        [TestCase("\f", true)]
+        [TestCase("\0", true)]
+        [TestCase("\t", true)]
+        [TestCase("\v", true)]
+        [TestCase(null, false)]
+        [Category("Inspections")]
+        public void UnreachableCaseInspection_ControlCharToLiteral_AreEqual(string constToken, bool expected)
+        {
+            var parseTreeValueVisitor = new ParseTreeValueVisitor(null, new List<VBAParser.EnumerationStmtContext>(), null) as ITestParseTreeVisitor;
+            Assert.AreEqual(expected, parseTreeValueVisitor.IsNonPrintingControlCharacter(constToken));
+        }
+
+        //https://github.com/rubberduck-vba/Rubberduck/issues/4659        
+        [Test]
+        [Category("Inspections")]
+        public void UnreachableCaseInspection_VbObjectErrorConstant()
+        {
+            var expectedUnreachableCount = 2;
+            string inputCode =
+@"
+Enum Fubar
+    Foo = vbObjectError + 1
+    Bar = vbObjectError + 2
+End Enum
+
+Sub Example(value As Long)
+    Select Case value
+        Case Fubar.Foo
+            Debug.Print ""Foo""
+        Case Fubar.Bar
+            Debug.Print ""Bar""
+        Case vbObjectError + 1 'unreachable
+            Debug.Print ""Unreachable""
+        Case -2147221502 'unreachable
+            Debug.Print ""Unreachable""
+    End Select
+End Sub
+";
+            (bool IsType, string ExpressionValue, string TypeName) TestGetValuedDeclaration(Declaration declaration)
+            {
+                if (declaration.IdentifierName.Equals("vbObjectError"))
+                {
+                    return (true, "-2147221504", Tokens.Long);
+                }
+                return (false, null, null);
+            }
+
+            var vbe = CreateStandardModuleProject(inputCode);
+
+            IEnumerable<Rubberduck.Parsing.Inspections.Abstract.IInspectionResult> actualResults;
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+                var inspection = new UnreachableCaseInspection(state);
+                var parseTreeValueVisitor = inspection.ParseTreeValueVisitor as ITestParseTreeVisitor;
+
+                parseTreeValueVisitor.InjectValuedDeclarationEvaluator(TestGetValuedDeclaration);
+
+                var inspector = InspectionsHelper.GetInspector(inspection);
+                actualResults = inspector.FindIssuesAsync(state, CancellationToken.None).Result;
+            }
+
+            var actualUnreachable = actualResults.Where(ar => ar.Description.Equals(InspectionResults.UnreachableCaseInspection_Unreachable));
+
+            Assert.AreEqual(expectedUnreachableCount, actualUnreachable.Count());
+        }
+
+        //https://github.com/rubberduck-vba/Rubberduck/issues/4680
+        [Test]
+        [Ignore("Issue 4680")]
+        [Category("Inspections")]
+        public void UnreachableCaseInspection_VbStringConstant()
+        {
+            string inputCode =
+@"
+Sub Foo(value As String)
+    Select Case value
+        Case ""Hello"" + vbNewLine + ""World""
+            MsgBox ""vbNewLine version""
+        Case ""Hello"" + vbCr + vbLf + ""World"" 'unreachable
+            MsgBox ""vbCr + vbLf version""
+        Case ""Reachable""
+            MsgBox ""Reachable""
+    End Select
+End Sub
+";
+            (string expectedMsg, string actualMsg) = CheckActualResultsEqualsExpected(inputCode, unreachable: 1);
+            Assert.AreEqual(expectedMsg, actualMsg);
+        }
+
         private static (string expectedMsg, string actualMsg) CheckActualResultsEqualsExpected(string inputCode, int unreachable = 0, int mismatch = 0, int caseElse = 0, int inherentlyUnreachable = 0, int overflow = 0)
         {
             var components = new List<(string moduleName, string inputCode)>() { ("TestModule1", inputCode) };
             return CheckActualResultsEqualsExpected(components, unreachable, mismatch, caseElse, inherentlyUnreachable, overflow);
         }
 
-        private static (string expectedMsg, string actualMsg) CheckActualResultsEqualsExpected(List<(string moduleName, string inputBlock)> inputCode, int unreachable = 0, int mismatch = 0, int caseElse = 0, int inherentlyUnreachable = 0, int overflow = 0)
+        private static (string expectedMsg, string actualMsg) CheckActualResultsEqualsExpected(List<(string moduleName, string inputCode)> components, int unreachable = 0, int mismatch = 0, int caseElse = 0, int inherentlyUnreachable = 0, int overflow = 0)
         {
             var expected = new Dictionary<string, int>
             {
@@ -2458,10 +2572,7 @@ private static (string expectedMsg, string actualMsg) CheckActualResultsEqualsEx
                 { InspectionResults.UnreachableCaseInspection_CaseElse, caseElse },
             };
 
-            var builder = new MockVbeBuilder();
-            var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected);
-            inputCode.ForEach(input => project.AddComponent(input.moduleName, NameToComponentType(input.moduleName), input.inputBlock));
-            var vbe = builder.AddProject(project.Build()).Build();
+            var vbe = CreateStandardModuleProject(components);
 
             IEnumerable<Rubberduck.Parsing.Inspections.Abstract.IInspectionResult> actualResults;
             using (var state = MockParser.CreateAndParse(vbe.Object))
@@ -2486,6 +2597,17 @@ private static (string expectedMsg, string actualMsg) CheckActualResultsEqualsEx
             return (expectedMsg, actualMsg);
         }
 
+        private Moq.Mock<IVBE> CreateStandardModuleProject(string inputCode)
+            => CreateStandardModuleProject(new List<(string moduleName, string inputCode)>() { ("TestModule1", inputCode) });
+
+        private static Moq.Mock<IVBE> CreateStandardModuleProject(List<(string moduleName, string inputCode)> components)
+        {
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("VBAProject", ProjectProtection.Unprotected);
+            components.ForEach(input => project.AddComponent(input.moduleName, NameToComponentType(input.moduleName), input.inputCode));
+            return builder.AddProject(project.Build()).Build();
+        }
+
         private static ComponentType NameToComponentType(string name)
             => name.StartsWith("Class") ? ComponentType.ClassModule : ComponentType.StandardModule;