Addresses Inspection False Positive: Issue 5456

Modifies IsResultReference(...) to avoid flagging an unused assignment that
preceeds a GoTo/Resume statement that branches execution to a
line in the procedure where the assignment could be used.

Author: BZngr

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -1,10 +1,12 @@
 using System.Collections.Generic;
 using System.Linq;
+using Antlr4.Runtime;
 using Rubberduck.CodeAnalysis.Inspections.Abstract;
 using Rubberduck.CodeAnalysis.Inspections.Extensions;
 using Rubberduck.Inspections.CodePathAnalysis;
 using Rubberduck.Inspections.CodePathAnalysis.Extensions;
 using Rubberduck.Inspections.CodePathAnalysis.Nodes;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
@@ -67,7 +69,7 @@ private IEnumerable<IdentifierReference> UnusedAssignments(Declaration localVari
             return UnusedAssignmentReferences(tree);
         }
 
-        public static List<IdentifierReference> UnusedAssignmentReferences(INode node)
+        private static List<IdentifierReference> UnusedAssignmentReferences(INode node)
         {
             var nodes = new List<IdentifierReference>();
 
@@ -98,7 +100,8 @@ public static List<IdentifierReference> UnusedAssignmentReferences(INode node)
 
         protected override bool IsResultReference(IdentifierReference reference, DeclarationFinder finder)
         {
-            return !IsAssignmentOfNothing(reference);
+            return !(IsAssignmentOfNothing(reference)
+                        || IsPotentiallyUsedViaResumeOrGoToExecutionBranch(reference, finder));
         }
 
         private static bool IsAssignmentOfNothing(IdentifierReference reference)
@@ -108,6 +111,140 @@ private static bool IsAssignmentOfNothing(IdentifierReference reference)
                 && setStmtContext.expression().GetText().Equals(Tokens.Nothing);
         }
 
+        /// <summary>
+        /// Filters false positive result references due to GoTo and Resume statements.  e.g., 
+        /// An ErrorHandler block that branches execution to a location where the asignment may be used. 
+        /// </summary>
+        /// <remarks>
+        /// Excludes Assignment references that meet the following conditions:
+        /// 1. Preceed a GoTo or Resume statement that branches execution to a line before the 
+        ///     assignment reference, and
+        /// 2. A non-assignment reference is present on a line that is:
+        ///     a) At or below the start of the execution branch, and 
+        ///     b) Above the next ExitStatement line (if one exists) or the end of the procedure
+        /// </remarks>
+        /// <param name="resultCandidate"></param>
+        /// <param name="finder"></param>
+        /// <returns></returns>
+        private static bool IsPotentiallyUsedViaResumeOrGoToExecutionBranch(IdentifierReference resultCandidate, DeclarationFinder finder)
+        {
+            if (!resultCandidate.Declaration.References.Any(rf => !rf.IsAssignment)) { return false; }
+
+            var labelIdLineNumberPairs = finder.DeclarationsWithType(DeclarationType.LineLabel)
+                                                .Where(label => resultCandidate.ParentScoping.Equals(label.ParentDeclaration))
+                                                .Select(lbl => (lbl.IdentifierName, lbl.Context.Start.Line));
+
+            return GotoExecutionBranchPotentiallyUsesVariable(resultCandidate, labelIdLineNumberPairs) 
+                || ResumeExecutionBranchPotentiallyUsesVariable(resultCandidate, labelIdLineNumberPairs);
+        }
+
+        private static bool GotoExecutionBranchPotentiallyUsesVariable(IdentifierReference resultCandidate, IEnumerable<(string, int)> labelIdLineNumberPairs)
+        {
+            var gotoCtxts = resultCandidate.ParentScoping.Context.GetDescendents<VBAParser.GoToStmtContext>()
+                .Where(gotoCtxt => gotoCtxt.Start.Line > resultCandidate.Context.Start.Line);
+
+            if (!gotoCtxts.Any()) { return false; }
+
+            var gotoStmt = GetFirstContextAfterLine(gotoCtxts, resultCandidate.Context.Start.Line);
+
+            if (gotoStmt == null) { return false; }
+
+            var executionBranchLine = DetermineExecutionBranchLine(gotoStmt.expression().GetText(), labelIdLineNumberPairs);
+
+            return IsPotentiallyUsedAssignment(resultCandidate, executionBranchLine);
+        }
+
+        private static bool ResumeExecutionBranchPotentiallyUsesVariable(IdentifierReference resultCandidate, IEnumerable<(string IdentifierName, int Line)> labelIdLineNumberPairs)
+        {
+            var resumeStmtCtxts = resultCandidate.ParentScoping.Context.GetDescendents<VBAParser.ResumeStmtContext>()
+                .Where(jumpCtxt => jumpCtxt.Start.Line > resultCandidate.Context.Start.Line);
+
+            if (!resumeStmtCtxts.Any()) { return false; }
+
+            var onErrorGotoStatements = resultCandidate.ParentScoping.Context.GetDescendents<VBAParser.OnErrorStmtContext>()
+                                .Where(errorStmtCtxt => !errorStmtCtxt.expression().GetText().Equals("0"))
+                                .ToDictionary(k => k.expression()?.GetText() ?? "0", v => v.Start.Line);
+
+            var errorHandlerLabelsAndLines = labelIdLineNumberPairs.Where(pair => onErrorGotoStatements.ContainsKey(pair.IdentifierName));
+            
+            //If the resultCandidate line preceeds all ErrorHandlers/Resume statements - it is not evaluated
+            if (errorHandlerLabelsAndLines.All(s => s.Line > resultCandidate.Context.Start.Line))
+            {
+                return false;
+            }
+
+            var resumeStmt = GetFirstContextAfterLine(resumeStmtCtxts, resultCandidate.Context.Start.Line);
+
+            if (resumeStmt == null) { return false; }
+
+            int? executionBranchLine = null;
+
+            var expression = resumeStmt.expression()?.GetText();
+
+            //For Resume and Resume Next, expression() is null
+            if (string.IsNullOrEmpty(expression))
+            {
+                //Get info for the errorHandlerLabel above the Resume statement
+                (string IdentifierName, int Line)? errorHandlerLabel = labelIdLineNumberPairs
+                                                            .Where(pair => resumeStmt.Start.Line > pair.Line)
+                                                            .OrderBy(pair => resumeStmt.Start.Line - pair.Line)
+                                                            .FirstOrDefault();
+
+                //Since the execution branch line for Resume and Resume Next statements 
+                //is indeterminant by static analysis, the On***GoTo statement
+                //is used as the execution branch line
+                if (errorHandlerLabel.HasValue && onErrorGotoStatements.ContainsKey(errorHandlerLabel.Value.IdentifierName))
+                {
+                    executionBranchLine = onErrorGotoStatements[errorHandlerLabel.Value.IdentifierName];
+                }
+            }
+            else
+            {
+                executionBranchLine = DetermineExecutionBranchLine(expression, labelIdLineNumberPairs);
+            }
+
+            return executionBranchLine.HasValue
+                ? IsPotentiallyUsedAssignment(resultCandidate, executionBranchLine.Value)
+                : false;
+        }
+
+        private static bool IsPotentiallyUsedAssignment(IdentifierReference resultCandidate, int executionBranchLine)
+        {
+            if (resultCandidate.Context.Start.Line <= executionBranchLine) { return false; }
+
+            var exitStmtCtxts = resultCandidate.ParentScoping.Context.GetDescendents<VBAParser.ExitStmtContext>()
+                                .Where(exitCtxt => exitCtxt.Start.Line > executionBranchLine
+                                        && exitCtxt.EXIT_DO() == null
+                                        && exitCtxt.EXIT_FOR() == null);
+
+            var exitStmtCtxt = GetFirstContextAfterLine(exitStmtCtxts, executionBranchLine);
+
+            var nonAssignmentReferences = resultCandidate.Declaration.References
+                                                .Where(rf => !rf.IsAssignment);
+
+            var possibleUse = exitStmtCtxt != null
+                ? nonAssignmentReferences.Where(rf => rf.Context.Start.Line >= executionBranchLine
+                                                        && rf.Context.Start.Line < exitStmtCtxt.Start.Line)
+                : nonAssignmentReferences.Where(rf => rf.Context.Start.Line >= executionBranchLine);
+
+            return possibleUse.Any();
+        }
+
+        private static int DetermineExecutionBranchLine(string expression, IEnumerable<(string IdentifierName, int Line)> IDandLinePairs)
+        {
+            if (int.TryParse(expression, out var parsedLineNumber))
+            {
+                return parsedLineNumber;
+            }
+            (string label, int lineNumber) = IDandLinePairs.Where(v => v.IdentifierName.Equals(expression)).Single();
+            return lineNumber;
+        }
+
+        private static T GetFirstContextAfterLine<T>(IEnumerable<T> stmtContexts, int targetLine) where T : ParserRuleContext 
+                                        => stmtContexts.Where(sc => sc.Start.Line > targetLine)
+                                                        .OrderBy(sc => sc.Start.Line - targetLine)
+                                                        .FirstOrDefault();
+
         protected override string ResultDescription(IdentifierReference reference)
         {
             return Description;