Merge pull request #2161 from Hosch250/Issue1667

Make UnassignedVariableUsage inspection only fire a result for the declaration, rather than each reference

Author: retailcoder

RetailCoder.VBE/Inspections/UnassignedVariableUsageInspection.cs

@@ -20,54 +20,47 @@ public UnassignedVariableUsageInspection(RubberduckParserState state)
 
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
-            var usages = UserDeclarations.Where(declaration => 
+            var declarations = UserDeclarations.Where(declaration => 
                 declaration.DeclarationType == DeclarationType.Variable
                 && !UserDeclarations.Any(d => d.DeclarationType == DeclarationType.UserDefinedType
                     && d.IdentifierName == declaration.AsTypeName)
                 && !declaration.IsSelfAssigned
-                && !declaration.References.Any(reference => reference.IsAssignment))
-                .SelectMany(declaration => declaration.References)
-                .Where(usage => !usage.IsInspectionDisabled(AnnotationName));
+                && !declaration.References.Any(reference => reference.IsAssignment));
 
             var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.Scope == "VBE7.DLL;VBA.Strings.Len");
             var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.Scope == "VBE7.DLL;VBA.Strings.LenB");
 
-            foreach (var issue in usages)
+            foreach (var issue in declarations)
             {
                 if (DeclarationReferencesContainsReference(lenFunction, issue) ||
                     DeclarationReferencesContainsReference(lenbFunction, issue))
                 {
                     continue;
                 }
 
-                yield return
-                    new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedModuleName,
-                        issue.Declaration);
+                yield return new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedName.QualifiedModuleName, issue);
             }
         }
 
-        private bool DeclarationReferencesContainsReference(Declaration parentDeclaration, IdentifierReference issue)
+        private bool DeclarationReferencesContainsReference(Declaration parentDeclaration, Declaration target)
         {
             if (parentDeclaration == null)
             {
                 return false;
             }
-
-            var lenUsesIssue = false;
-            foreach (var reference in parentDeclaration.References)
+            
+            foreach (var targetReference in target.References)
             {
-                var context = (ParserRuleContext) reference.Context.Parent;
-                if (context.GetSelection().Contains(issue.Selection))
+                foreach (var reference in parentDeclaration.References)
                 {
-                    lenUsesIssue = true;
-                    break;
+                    var context = (ParserRuleContext) reference.Context.Parent;
+                    if (context.GetSelection().Contains(targetReference.Selection))
+                    {
+                        return true;
+                    }
                 }
             }
-
-            if (lenUsesIssue)
-            {
-                return true;
-            }
+            
             return false;
         }
     }

RetailCoder.VBE/Inspections/UnassignedVariableUsageInspectionResult.cs

@@ -15,7 +15,7 @@ public UnassignedVariableUsageInspectionResult(IInspection inspection, ParserRul
         {
             _quickFixes = new CodeInspectionQuickFix[]
             {
-                new RemoveUnassignedVariableUsageQuickFix(Context, QualifiedSelection),
+                //new RemoveUnassignedVariableUsageQuickFix(Context, QualifiedSelection),   // removed until we can reinstate this for a specific reference
                 new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName), 
             };
         }
@@ -43,7 +43,7 @@ public override void Fix()
             var module = Selection.QualifiedName.Component.CodeModule;
             var selection = Selection.Selection;
 
-            var originalCodeLines = module.get_Lines(selection.StartLine, selection.LineCount)
+            var originalCodeLines = module.Lines[selection.StartLine, selection.LineCount]
                 .Replace(Environment.NewLine, " ")
                 .Replace("_", string.Empty);
 

RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs

@@ -46,16 +46,21 @@ Dim bb As Boolean
             Assert.AreEqual(1, inspectionResults.Count());
         }
 
+        // this test will eventually be removed once we can fire the inspection on a specific reference
         [TestMethod]
         [TestCategory("Inspections")]
-        public void UnassignedVariableUsage_DoesNotReturnResult()
+        public void UnassignedVariableUsage_ReturnsSingleResult_MultipleReferences()
         {
             const string inputCode =
-@"Sub Foo()
-    Dim b As Boolean
-    Dim bb As Boolean
-    b = True
-    bb = b
+@"Sub tester()
+    Dim myarr() As Variant
+    Dim i As Long
+
+    ReDim myarr(1 To 10)
+
+    For i = LBound(myarr) To UBound(myarr)
+    Next
+
 End Sub";
 
             //Arrange
@@ -75,19 +80,18 @@ Dim bb As Boolean
             var inspection = new UnassignedVariableUsageInspection(parser.State);
             var inspectionResults = inspection.GetInspectionResults();
 
-            Assert.IsFalse(inspectionResults.Any());
+            Assert.AreEqual(1, inspectionResults.Count());
         }
 
         [TestMethod]
         [TestCategory("Inspections")]
-        public void UnassignedVariableUsage_Ignored_DoesNotReturnResult()
+        public void UnassignedVariableUsage_DoesNotReturnResult()
         {
             const string inputCode =
 @"Sub Foo()
     Dim b As Boolean
     Dim bb As Boolean
-
-    '@Ignore UnassignedVariableUsage
+    b = True
     bb = b
 End Sub";
 
@@ -113,28 +117,24 @@ Dim bb As Boolean
 
         [TestMethod]
         [TestCategory("Inspections")]
-        public void UnassignedVariableUsage_QuickFixWorks()
+        public void UnassignedVariableUsage_Ignored_DoesNotReturnResult()
         {
             const string inputCode =
 @"Sub Foo()
+    '@Ignore UnassignedVariableUsage
     Dim b As Boolean
     Dim bb As Boolean
-    bb = b
-End Sub";
 
-            const string expectedCode =
-@"Sub Foo()
-    Dim b As Boolean
-    Dim bb As Boolean
-    TODOTODO = TODO
+    bb = b
 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 project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none)
+                .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
+                .Build();
+            var vbe = builder.AddProject(project).Build();
+
             var mockHost = new Mock<IHostApplication>();
             mockHost.SetupAllProperties();
             var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock<ISinks>().Object));
@@ -145,11 +145,49 @@ Dim bb As Boolean
             var inspection = new UnassignedVariableUsageInspection(parser.State);
             var inspectionResults = inspection.GetInspectionResults();
 
-            inspectionResults.First().QuickFixes.First().Fix();
-            
-            Assert.AreEqual(expectedCode, module.Lines());
+            Assert.IsFalse(inspectionResults.Any());
         }
 
+//        Ignored until we can reinstate the quick fix on a specific reference
+//        [TestMethod]
+//        [TestCategory("Inspections")]
+//        public void UnassignedVariableUsage_QuickFixWorks()
+//        {
+//            const string inputCode =
+//@"Sub Foo()
+//    Dim b As Boolean
+//    Dim bb As Boolean
+//    bb = b
+//End Sub";
+
+//            const string expectedCode =
+//@"Sub Foo()
+//    Dim b As Boolean
+//    Dim bb As Boolean
+//    TODOTODO = TODO
+//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(new Mock<ISinks>().Object));
+
+//            parser.Parse(new CancellationTokenSource());
+//            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+//            var inspection = new UnassignedVariableUsageInspection(parser.State);
+//            var inspectionResults = inspection.GetInspectionResults();
+
+//            inspectionResults.First().QuickFixes.First().Fix();
+            
+//            Assert.AreEqual(expectedCode, module.Lines());
+//        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void UnassignedVariableUsage_IgnoreQuickFixWorks()
@@ -163,9 +201,9 @@ Dim bb As Boolean
 
             const string expectedCode =
 @"Sub Foo()
+'@Ignore UnassignedVariableUsage
     Dim b As Boolean
     Dim bb As Boolean
-'@Ignore UnassignedVariableUsage
     bb = b
 End Sub";