Use visitor in NonReturningFunctionInspection properly

Previously, it was kind of used like a listener, but calling it a visitor. Now, it specifies the result aggregation method and actually short-circuits once the result is known.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/NonReturningFunctionInspection.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using Antlr4.Runtime.Tree;
 using Rubberduck.CodeAnalysis.Inspections.Abstract;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
@@ -122,48 +123,58 @@ protected override string ResultDescription(Declaration declaration)
         private class FunctionReturnValueAssignmentLocator : VBAParserBaseVisitor<bool>
         {
             private readonly string _name;
-            private bool _result;
             private bool _inFunctionReturnWithExpression;
 
             public FunctionReturnValueAssignmentLocator(string name)
             {
                 _name = name;
+                _inFunctionReturnWithExpression = false;
             }
 
-            public override bool VisitBlock(VBAParser.BlockContext context)
+            protected override bool DefaultResult => false;
+
+            protected override bool ShouldVisitNextChild(IRuleNode node, bool currentResult)
             {
-                base.VisitBlock(context);
-                return _result;
+                return !currentResult;
             }
+
+            //This is actually the default implementation, but for explicities sake stated here.
+            protected override bool AggregateResult(bool aggregate, bool nextResult)
+            {
+                return nextResult;
+            }
+
             public override bool VisitWithStmt(VBAParser.WithStmtContext context)
             {
                 var oldInFunctionReturnWithExpression = _inFunctionReturnWithExpression;
                 _inFunctionReturnWithExpression = context.expression().GetText() == _name;
-                base.VisitWithStmt(context);
+                var result = base.VisitWithStmt(context);
                 _inFunctionReturnWithExpression = oldInFunctionReturnWithExpression;
-                return _result;
+                return result;
             }
 
             public override bool VisitLetStmt(VBAParser.LetStmtContext context)
             {
                 var LHS = context.lExpression();
+                if (_inFunctionReturnWithExpression
+                        && LHS is VBAParser.WithMemberAccessExprContext)
+                {
+                    return true;
+                }
                 var leftmost = LHS.GetChild(0).GetText();
-                _result = _result 
-                    || leftmost == _name 
-                    || (_inFunctionReturnWithExpression 
-                        && LHS is VBAParser.WithMemberAccessExprContext);
-                return _result;
+                return leftmost == _name;
             }
 
             public override bool VisitSetStmt(VBAParser.SetStmtContext context)
             {
                 var LHS = context.lExpression();
+                if (_inFunctionReturnWithExpression
+                        && LHS is VBAParser.WithMemberAccessExprContext)
+                {
+                    return true;
+                }
                 var leftmost = LHS.GetChild(0).GetText();
-                _result = _result
-                    || leftmost == _name
-                    || (_inFunctionReturnWithExpression
-                        && LHS is VBAParser.WithMemberAccessExprContext);
-                return _result;
+                return leftmost == _name;
             }
         }
     }