Simplifying parsing optional semicolons/commas

Parser/MParser.cs

@@ -676,15 +676,34 @@ namespace Parser
             return lhs;
         }
 
-        private SwitchCaseNode ParseSwitchCase()
+        private List<TokenNode> ParseOptionalCommas()
         {
-            var caseKeyword = EatIdentifier("case");
-            var caseId = ParseExpression();
             var commas = new List<TokenNode>();
             while (CurrentToken.Kind == TokenKind.Comma)
             {
                 commas.Add(Factory.Token(EatToken()));
             }
+
+            return commas;
+        }
+
+        private List<TokenNode> ParseOptionalSemicolonsOrCommas()
+        {
+            var commas = new List<TokenNode>();
+            while (CurrentToken.Kind == TokenKind.Comma
+                   || CurrentToken.Kind == TokenKind.Semicolon)
+            {
+                commas.Add(Factory.Token(EatToken()));
+            }
+
+            return commas;
+        }
+
+        private SwitchCaseNode ParseSwitchCase()
+        {
+            var caseKeyword = EatIdentifier("case");
+            var caseId = ParseExpression();
+            var commas = ParseOptionalCommas();
             var statementList = ParseStatements();
             return Factory.SwitchCase(Factory.Token(caseKeyword), caseId, statementList, commas);
         }
@@ -693,11 +712,7 @@ namespace Parser
         {
             var switchKeyword = EatIdentifier("switch");
             var expression = ParseExpression();
-            var commas = new List<TokenNode>();
+            var commas = ParseOptionalCommas();
-            while (CurrentToken.Kind == TokenKind.Comma)
-            {
-                commas.Add(Factory.Token(EatToken()));
-            }
             var casesList = new List<SwitchCaseNode>();
             while (CurrentToken.Kind == TokenKind.Identifier
                    && CurrentToken.PureToken.LiteralText == "case")
@@ -717,46 +732,30 @@ namespace Parser
         public ExpressionStatementNode ParseExpressionStatement()
         {
             var statement = ParseExpression();
-            if (CurrentToken.Kind == TokenKind.Semicolon)
+            var possibleSemicolonOrComma = PossibleSemicolonOrComma();
-            {
+            return Factory.ExpressionStatement(statement, possibleSemicolonOrComma);
-                var semicolon = EatToken();
-                return Factory.ExpressionStatement(statement, Factory.Token(semicolon));
-            }
-
-            return Factory.ExpressionStatement(statement);
         }
 
         public WhileStatementNode ParseWhileStatement()
         {
             var whileKeyword = EatToken();
             var condition = ParseExpression();
-            var commas = new List<TokenNode>();
+            var commas = ParseOptionalCommas();
-            while (CurrentToken.Kind == TokenKind.Comma)
-            {
-                commas.Add(Factory.Token(EatToken()));
-            }
             var body = ParseStatements();
             var endKeyword = EatIdentifier("end");
+            var semicolonOrComma = PossibleSemicolonOrComma();
             return Factory.WhileStatement(
                 Factory.Token(whileKeyword),
                 condition,
+                commas,
                 body,
                 Factory.Token(endKeyword),
-                commas);
+                semicolonOrComma);
         }
 
         public StatementNode ParseStatement()
         {
             var statement = ParseStatementCore();
-            if (statement != null)
-            {
-                if (CurrentToken.Kind == TokenKind.Semicolon
-                    || CurrentToken.Kind == TokenKind.Comma)
-                {
-                    statement = Factory.AppendSemicolonOrComma(statement, Factory.Token(EatToken()));
-                }
-            }
-
             return statement;
         }
 
@@ -764,12 +763,7 @@ namespace Parser
         {
             var ifKeyword = Factory.Token(EatToken());
             var condition = ParseExpression();
-            var commas = new List<TokenNode>();
+            var commas = ParseOptionalSemicolonsOrCommas();
-            while (CurrentToken.Kind == TokenKind.Comma
-                   || CurrentToken.Kind == TokenKind.Semicolon)
-            {
-                commas.Add(Factory.Token(EatToken()));
-            }
             var body = ParseStatements();
             TokenNode elseKeyword = null;
             StatementListNode elseBody = null;
@@ -788,22 +782,25 @@ namespace Parser
                 return Factory.IfStatement(
                     ifKeyword,
                     condition,
+                    commas,
                     body,
                     null,
                     elseBody,
                     null,
-                    commas);
+                    null);
             }
 
             var endKeyword = Factory.Token(EatIdentifier("end"));
+            var possibleSemicolonOrComma = PossibleSemicolonOrComma();
             return Factory.IfStatement(
                 ifKeyword,
                 condition,
+                commas,
                 body,
                 elseKeyword,
                 elseBody,
                 endKeyword,
-                commas);
+                possibleSemicolonOrComma);
         }
 
         public ForStatementNode ParseForStatement()
@@ -816,12 +813,7 @@ namespace Parser
             }
 
             var forAssignment = (AssignmentExpressionNode) expression;
-            var commas = new List<TokenNode>();
+            var commas = ParseOptionalSemicolonsOrCommas();
-            while (CurrentToken.Kind == TokenKind.Comma
-                   || CurrentToken.Kind == TokenKind.Semicolon)
-            {
-                commas.Add(Factory.Token(EatToken()));
-            }
 
             var body = ParseStatements();
             var endKeyword = Factory.Token(EatIdentifier("end"));

Parser/SyntaxFactory.cs

@@ -219,16 +219,13 @@ namespace Parser
             return new UnquotedStringLiteralNode(stringLiteral);
         }
 
-        public ExpressionStatementNode ExpressionStatement(ExpressionNode expression)
-        {
-            var children = new List<SyntaxNode> {expression};
-            return new ExpressionStatementNode(children, expression, null);
-        }
-
         public ExpressionStatementNode ExpressionStatement(ExpressionNode expression, TokenNode semicolonOrComma)
         {
             var children = new List<SyntaxNode> {expression, semicolonOrComma};
-            return new ExpressionStatementNode(children, expression, semicolonOrComma);
+            return new ExpressionStatementNode(
+                RemoveNulls(children),
+                expression,
+                semicolonOrComma);
         }
 
         public CellArrayElementAccessExpressionNode CellArrayElementAccessExpression(
@@ -356,10 +353,10 @@ namespace Parser
         public WhileStatementNode WhileStatement(
             TokenNode whileKeyword,
             ExpressionNode condition,
+            List<TokenNode> optionalCommasAfterCondition,
             StatementListNode body,
             TokenNode end,
-            List<TokenNode> optionalCommasAfterCondition = null,
+            TokenNode semicolonOrComma)
-            TokenNode semicolonOrComma = null)
         {
             var children = new List<SyntaxNode>
             {
@@ -391,11 +388,12 @@ namespace Parser
         public IfStatementNode IfStatement(
             TokenNode ifKeyword,
             ExpressionNode condition,
+            List<TokenNode> optionalCommasAfterCondition,
             StatementListNode body,
             TokenNode elseKeyword,
             StatementListNode elseBody,
             TokenNode endKeyword,
-            List<TokenNode> optionalCommasAfterCondition = null)
+            TokenNode possibleSemicolonOrComma)
         {
             var children = new List<SyntaxNode>
             {
@@ -407,6 +405,7 @@ namespace Parser
             children.Add(elseKeyword);
             children.Add(elseBody);
             children.Add(endKeyword);
+            children.Add(possibleSemicolonOrComma);
 
             return new IfStatementNode(
                 RemoveNulls(children),
@@ -416,7 +415,8 @@ namespace Parser
                 body,
                 elseKeyword,
                 elseBody,
-                endKeyword);
+                endKeyword,
+                possibleSemicolonOrComma);
         }
 
         public ParenthesizedExpressionNode ParenthesizedExpression(

Parser/SyntaxNode.cs

@@ -572,8 +572,9 @@ namespace Parser
             StatementListNode body,
             TokenNode elseKeyword,
             StatementListNode elseBody,
-            TokenNode endKeyword
+            TokenNode endKeyword,
-            ) : base(children)
+            TokenNode possibleSemicolonOrComma
+            ) : base(children, possibleSemicolonOrComma)
         {
             IfKeyword = ifKeyword;
             Condition = condition;