Add support for VB6 versions of Len and LenB, simplify inspection, add tests.

Author: comintern

Rubberduck.CodeAnalysis/Inspections/Concrete/UnassignedVariableUsageInspection.cs

@@ -1,10 +1,8 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Antlr4.Runtime;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
-using Rubberduck.Parsing;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
@@ -18,6 +16,15 @@ public sealed class UnassignedVariableUsageInspection : InspectionBase
         public UnassignedVariableUsageInspection(RubberduckParserState state)
             : base(state) { }
 
+        //See https://github.com/rubberduck-vba/Rubberduck/issues/2010 for why these are being excluded.
+        private static readonly List<string> IgnoredFunctions = new List<string>
+        {
+            "VBE7.DLL;VBA.Strings.Len",
+            "VBE7.DLL;VBA.Strings.LenB",
+            "VBA6.DLL;VBA.Strings.Len",
+            "VBA6.DLL;VBA.Strings.LenB"
+        };
+
         protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         {
             var declarations = State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
@@ -27,42 +34,16 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                     && !declaration.IsSelfAssigned
                     && !declaration.References.Any(reference => reference.IsAssignment));
 
-            //See https://github.com/rubberduck-vba/Rubberduck/issues/2010 for why these are being excluded.
-            //TODO: These need to be modified to correctly work in VB6.
-            var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));
-            var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.LenB"));
+            var excludedDeclarations = BuiltInDeclarations.Where(decl => IgnoredFunctions.Contains(decl.QualifiedName.ToString())).ToList();
 
-            return declarations.Where(d => d.References.Any() &&
-                                           !DeclarationReferencesContainsReference(lenFunction, d) &&
-                                           !DeclarationReferencesContainsReference(lenbFunction, d))
-                               .SelectMany(d => d.References)
-                               .Where(r => !r.IsIgnoringInspectionResultFor(AnnotationName))
-                               .Select(r => new IdentifierReferenceInspectionResult(this,
-                                                                 string.Format(InspectionResults.UnassignedVariableUsageInspection, r.IdentifierName),
-                                                                 State,
-                                                                 r)).ToList();
-        }
-
-        private bool DeclarationReferencesContainsReference(Declaration parentDeclaration, Declaration target)
-        {
-            if (parentDeclaration == null)
-            {
-                return false;
-            }
-            
-            foreach (var targetReference in target.References)
-            {
-                foreach (var reference in parentDeclaration.References)
-                {
-                    var context = (ParserRuleContext) reference.Context.Parent;
-                    if (context.GetSelection().Contains(targetReference.Selection))
-                    {
-                        return true;
-                    }
-                }
-            }
-            
-            return false;
+            return declarations.Except(excludedDeclarations)
+                .Where(d => d.References.Any())
+                .SelectMany(d => d.References)
+                .Where(r => !r.IsIgnoringInspectionResultFor(AnnotationName))
+                .Select(r => new IdentifierReferenceInspectionResult(this,
+                    string.Format(InspectionResults.UnassignedVariableUsageInspection, r.IdentifierName),
+                    State,
+                    r)).ToList();
         }
     }
 }

RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs

@@ -112,6 +112,30 @@ Dim bb As Boolean
             }
         }
 
+        [Test]
+        [Category("Inspections")]
+        public void UnassignedVariableUsage_Ignored_DoesNotReturnResultMultipleIgnores()
+        {
+            const string inputCode =
+                @"Sub Foo()    
+    Dim b As Boolean
+    Dim bb As Boolean
+
+'@Ignore UnassignedVariableUsage, VariableNotAssigned
+    bb = b
+End Sub";
+
+            var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+
+                var inspection = new UnassignedVariableUsageInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.IsFalse(inspectionResults.Any());
+            }
+        }
+
         [Test]
         [Category("Inspections")]
         public void UnassignedVariableUsage_NoResultIfNoReferences()
@@ -132,6 +156,48 @@ Dim foo
             }
         }
 
+        [Test]
+        [Category("Inspections")]
+        public void UnassignedVariableUsage_NoResultForLenFunction()
+        {
+            const string inputCode =
+                @"Sub DoSomething()
+    Dim foo As LongPtr
+    Debug.Print Len(foo)
+End Sub";
+
+            var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+
+                var inspection = new UnassignedVariableUsageInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.IsFalse(inspectionResults.Any());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void UnassignedVariableUsage_NoResultForLenBFunction()
+        {
+            const string inputCode =
+                @"Sub DoSomething()
+    Dim foo As LongPtr
+    Debug.Print LenB(foo)
+End Sub";
+
+            var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out _);
+            using (var state = MockParser.CreateAndParse(vbe.Object))
+            {
+
+                var inspection = new UnassignedVariableUsageInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.IsFalse(inspectionResults.Any());
+            }
+        }
+
         [Test]
         [Category("Inspections")]
         public void InspectionName()