Detect comma and semicolon violations

Author: Kapil Borle

Rules/Strings.resx

@@ -933,4 +933,10 @@
   <data name="UseWhitespaceErrorOperator" xml:space="preserve">
     <value>Use space before and after binary and assignment operators.</value>
   </data>
+  <data name="UseWhitespaceErrorSeparatorComma" xml:space="preserve">
+    <value>Use space before a comma.</value>
+  </data>
+  <data name="UseWhitespaceErrorSeparatorSemi" xml:space="preserve">
+    <value>Use space before a semi-colon.</value>
+  </data>
 </root>

Rules/UseWhitespace.cs

@@ -29,7 +29,7 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
 #endif
     public class UseWhitespace : ConfigurableRule
     {
-        private enum ErrorKind { Brace, Paren, Operator };
+        private enum ErrorKind { Brace, Paren, Operator, SeparatorComma, SeparatorSemi };
         private const int whiteSpaceSize = 1;
         private const string whiteSpace = " ";
 
@@ -45,6 +45,9 @@ private List<Func<TokenOperations, IEnumerable<DiagnosticRecord>>> violationFind
         [ConfigurableRuleProperty(defaultValue: true)]
         public bool CheckOperator { get; protected set; }
 
+        [ConfigurableRuleProperty(defaultValue: true)]
+        public bool CheckSeparator { get; protected set; }
+
         public override void ConfigureRule(IDictionary<string, object> paramValueMap)
         {
             base.ConfigureRule(paramValueMap);
@@ -62,6 +65,11 @@ public override void ConfigureRule(IDictionary<string, object> paramValueMap)
             {
                 violationFinders.Add(FindOperatorViolations);
             }
+
+            if (CheckSeparator)
+            {
+                violationFinders.Add(FindSeparatorViolations);
+            }
         }
 
         /// <summary>
@@ -95,6 +103,10 @@ private string GetError(ErrorKind kind)
                     return string.Format(CultureInfo.CurrentCulture, Strings.UseWhitespaceErrorBeforeBrace);
                 case ErrorKind.Operator:
                     return string.Format(CultureInfo.CurrentCulture, Strings.UseWhitespaceErrorOperator);
+                case ErrorKind.SeparatorComma:
+                    return string.Format(CultureInfo.CurrentCulture, Strings.UseWhitespaceErrorSeparatorComma);
+                case ErrorKind.SeparatorSemi:
+                    return string.Format(CultureInfo.CurrentCulture, Strings.UseWhitespaceErrorSeparatorSemi);
                 default:
                     return string.Format(CultureInfo.CurrentCulture, Strings.UseWhitespaceErrorBeforeParen);
             }
@@ -147,6 +159,45 @@ private IEnumerable<DiagnosticRecord> FindOpenParenViolations(TokenOperations to
             }
         }
 
+        private IEnumerable<DiagnosticRecord> FindSeparatorViolations(TokenOperations tokenOperations)
+        {
+            Func<LinkedListNode<Token>, bool> predicate = node =>
+            {
+                return node.Next != null
+                    && !IsPreviousTokenApartByWhitespace(node.Next);
+            };
+
+            Func<Token, ErrorKind, DiagnosticRecord> getDiagnosticRecord = (token, errKind) =>
+            {
+                return new DiagnosticRecord(
+                    GetError(errKind),
+                    token.Extent,
+                    GetName(),
+                    GetDiagnosticSeverity(),
+                    token.Extent.File,
+                    null,
+                    null);
+            };
+
+            foreach (var tokenNode in tokenOperations.GetTokenNodes(TokenKind.Comma).Where(predicate))
+            {
+                yield return getDiagnosticRecord(tokenNode.Value, ErrorKind.SeparatorComma);
+            }
+
+            foreach (var tokenNode in tokenOperations.GetTokenNodes(TokenKind.Semi).Where(predicate))
+            {
+                // semi-colon can be followed by newline or end of input
+                if (tokenNode.Next.Value.Kind == TokenKind.EndOfInput
+                    || tokenNode.Next.Value.Kind == TokenKind.NewLine)
+                {
+                    continue;
+                }
+
+                yield return getDiagnosticRecord(tokenNode.Value, ErrorKind.SeparatorSemi);
+            }
+        }
+
+
         private bool IsKeyword(Token token)
         {
             switch (token.Kind)