Allow multiple WithEvents declarations in variable list. Closes #4591

Author: comintern

Rubberduck.Parsing/Grammar/VBAParser.g4

@@ -549,9 +549,9 @@ upperBound : constantExpression;
 
 constantExpression : expression;
 
-variableStmt : (DIM | STATIC | visibility) whiteSpace (WITHEVENTS whiteSpace)? variableListStmt;
+variableStmt : (DIM | STATIC | visibility) whiteSpace variableListStmt;
 variableListStmt : variableSubStmt (whiteSpace? COMMA whiteSpace? variableSubStmt)*;
-variableSubStmt : identifier (whiteSpace? LPAREN whiteSpace? (subscripts whiteSpace?)? RPAREN)? (whiteSpace asTypeClause)?;
+variableSubStmt : (WITHEVENTS whiteSpace)? identifier (whiteSpace? LPAREN whiteSpace? (subscripts whiteSpace?)? RPAREN)? (whiteSpace asTypeClause)?;
 
 whileWendStmt : 
     WHILE whiteSpace expression endOfStatement 

Rubberduck.Parsing/VBA/DeclarationResolving/DeclarationSymbolsListener.cs

@@ -685,7 +685,7 @@ public override void EnterVariableSubStmt(VBAParser.VariableSubStmtContext conte
                     ? Tokens.Variant
                     : asTypeClause.type().GetText()
                 : SymbolList.TypeHintToTypeName[typeHint];
-            var withEvents = parent.WITHEVENTS() != null;
+            var withEvents = context.WITHEVENTS() != null;
             var isAutoObject = asTypeClause != null && asTypeClause.NEW() != null;
             bool isArray = context.LPAREN() != null;
             AddDeclaration(

RubberduckTests/Grammar/VBAParserTests.cs

@@ -3517,6 +3517,20 @@ End Type
             AssertTree(parseResult.Item1, parseResult.Item2, "//unrestrictedIdentifier", matches => matches.Count == 1);
         }
 
+        
+        [Test]
+        [Category("Parser")]
+        [TestCase("Private WithEvents foo As EventSource, WithEvents bar As EventSource", 2)]
+        [TestCase("Private WithEvents foo As EventSource, bar As EventSource", 2)]
+        [TestCase("Private foo As EventSource, WithEvents bar As EventSource", 2)]
+        [TestCase("Private foo As EventSource, bar As EventSource", 2)]
+        [TestCase("Private WithEvents foo As EventSource", 1)]
+        public void WithEventsInVariableList(string code, int count)
+        {
+            var parseResult = Parse(code);
+            AssertTree(parseResult.Item1, parseResult.Item2, "//variableSubStmt", matches => matches.Count == count);
+        }
+
         private Tuple<VBAParser, ParserRuleContext> Parse(string code, PredictionMode predictionMode = null)
         {
             var stream = new AntlrInputStream(code);

RubberduckTests/Symbols/VariableDeclarationTests.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using NUnit.Framework;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.SafeComWrappers;
+using RubberduckTests.Mocks;
+
+namespace RubberduckTests.Symbols
+{
+    [TestFixture]
+    public class VariableDeclarationTests
+    {
+        [Test]
+        [TestCase("Private WithEvents foo As EventSource", true)]
+        [TestCase("Private foo As EventSource", false)]
+        [Category("Resolver")]
+        public void WithEventsIsResolvedCorrectly(string declaration, bool withEvents)
+        {
+            var variables = ArrangeAndGetVariableDeclarations(ComponentType.ClassModule, declaration);
+            var foo = variables.Single();
+            Assert.AreEqual(withEvents, foo.IsWithEvents);  
+        }
+
+        [Test]
+        [TestCase("Private WithEvents {0} As EventSource, WithEvents {1} As EventSource", "foo", "bar", true, true)]
+        [TestCase("Private {0} As EventSource, WithEvents {1} As EventSource", "foo", "bar", false, true)]
+        [TestCase("Private WithEvents {0} As EventSource, {1} As EventSource", "foo", "bar", true, false)]
+        [TestCase("Private {0} As EventSource, {1} As EventSource", "foo", "bar", false, false)]
+        [Category("Resolver")]
+        public void WithEventsIsResolvedCorrectlyVariableList(string template, string first, string second, bool firstEvents, bool secondEvents)
+        {
+            var variables = ArrangeAndGetVariableDeclarations(ComponentType.ClassModule, string.Format(template, first, second));
+            Assert.AreEqual(2, variables.Count);
+            Assert.AreEqual(firstEvents, variables.Single(variable => variable.IdentifierName.Equals(first)).IsWithEvents);
+            Assert.AreEqual(secondEvents, variables.Single(variable => variable.IdentifierName.Equals(second)).IsWithEvents);
+        }
+
+        private List<VariableDeclaration> ArrangeAndGetVariableDeclarations(ComponentType moduleType, string code)
+        {
+            var vbe = new MockVbeBuilder()
+                .ProjectBuilder("TestProject", ProjectProtection.Unprotected)
+                .AddComponent("UnderTest", moduleType, code, new Selection(1, 1))
+                .AddProjectToVbeBuilder()
+                .Build();
+
+            using (var parser = MockParser.Create(vbe.Object))
+            {
+                parser.Parse(new CancellationTokenSource());
+
+                return parser.State.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
+                    .Cast<VariableDeclaration>()
+                    .ToList();
+            }
+        } 
+    }
+}