Add rule to check for consistent whitespace style

Engine/Generic/CorrectionExtent.cs

@@ -111,7 +111,22 @@ public CorrectionExtent(
             ThrowIfInvalidArguments();
         }
 
+        public CorrectionExtent(
+            IScriptExtent violationExtent,
+            string replacementText,
+            string filePath,
+            string description)
+            : this(
+                violationExtent.StartLineNumber,
+                violationExtent.EndLineNumber,
+                violationExtent.StartColumnNumber,
+                violationExtent.EndColumnNumber,
+                replacementText,
+                filePath,
+                description)
+        {
 
+        }
 
         private void ThrowIfInvalidArguments()
         {

Engine/Settings/CodeFormatting.psd1

@@ -2,7 +2,8 @@
     IncludeRules = @(
         'PSPlaceOpenBrace',
         'PSPlaceCloseBrace',
-        'PSUseConsistentIndentation'
+        'PSUseConsistentIndentation',
+        'PSUseWhitespace'
     )
 
     Rules = @{
@@ -20,5 +21,14 @@
             Enable = $true
             IndentationSize = 4
         }
+
+        PSUseWhitespace = @{
+            Enable = $true
+            CheckOpenBrace = $true
+            CheckOpenParen = $true
+            CheckOperator = $true
+            CheckSeparator = $true
+        }
+
     }
 }

Engine/TokenOperations.cs

@@ -22,8 +22,11 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
     public class TokenOperations
     {
         private readonly Token[] tokens;
+        private LinkedList<Token> tokensLL;
         private readonly Ast ast;
 
+        public Ast Ast { get { return ast; } }
+
         /// <summary>
         /// Initializes the fields of the TokenOperations class.
         /// </summary>
@@ -43,6 +46,7 @@ public TokenOperations(Token[] tokens, Ast ast)
 
             this.tokens = tokens;
             this.ast = ast;
+            this.tokensLL = new LinkedList<Token>(this.tokens);
         }
 
         /// <summary>
@@ -105,5 +109,55 @@ private IEnumerable<Token> GetBraceInCommandElement(TokenKind tokenKind)
                 }
             }
         }
+
+        public IEnumerable<LinkedListNode<Token>> GetTokenNodes(TokenKind kind)
+        {
+            return GetTokenNodes((token) => token.Kind == kind);
+        }
+
+        public IEnumerable<LinkedListNode<Token>> GetTokenNodes(Func<Token, bool> predicate)
+        {
+            var token = tokensLL.First;
+            while (token != null)
+            {
+                if (predicate(token.Value))
+                {
+                    yield return token;
+                }
+                token = token.Next;
+            }
+        }
+
+        private IEnumerable<Tuple<Token, int>> GetTokenAndPrecedingWhitespace(TokenKind kind)
+        {
+            var lCurlyTokens = GetTokenNodes(TokenKind.LCurly);
+            foreach (var item in lCurlyTokens)
+            {
+                if (item.Previous == null
+                    || !OnSameLine(item.Previous.Value, item.Value))
+                {
+                    continue;
+                }
+
+                yield return new Tuple<Token, int>(
+                    item.Value,
+                    item.Value.Extent.StartColumnNumber - item.Previous.Value.Extent.EndColumnNumber);
+            }
+        }
+
+        public IEnumerable<Tuple<Token, int>> GetOpenBracesWithWhiteSpacesBefore()
+        {
+            return GetTokenAndPrecedingWhitespace(TokenKind.LCurly);
+        }
+
+        public IEnumerable<Tuple<Token, int>> GetOpenParensWithWhiteSpacesBefore()
+        {
+            return GetTokenAndPrecedingWhitespace(TokenKind.LParen);
+        }
+
+        private bool OnSameLine(Token token1, Token token2)
+        {
+            return token1.Extent.StartLineNumber == token2.Extent.EndLineNumber;
+        }
     }
 }

RuleDocumentation/UseConsistentWhitespace.md

@@ -0,0 +1,37 @@
+# UseConsistentWhitespace
+**Severity Level: Warning**
+
+## Description
+This rule enforces consistent brace, parenthesis, binary operator, assignment operator and separator styles. For more information please see the [Parameters](#parameters) section.
+
+**Note**: This rule is not enabled by default. The user needs to enable it through settings.
+
+## Configuration
+```powershell
+    Rules = @{
+        PSUseConsistentWhitespace = @{
+            Enable = $true
+            CheckOpenBrace = $true
+            CheckOpenParen = $true
+            CheckOperator = $true
+            CheckSeparator = $true
+        }
+    }
+```
+
+### Parameters
+
+#### Enable: bool (Default value is `$false`)
+Enable or disable the rule during ScriptAnalyzer invocation.
+
+#### CheckOpenBrace: bool (Default value is `$true`)
+Checks if there is a space between a keyword and its corresponding open brace. E.g. `foo { }`.
+
+#### CheckOpenParen: bool (Default value is `$true`)
+Checks if there is space between a keyword and its corresponding open parenthesis. E.g. `if (true)`.
+
+#### CheckOperator: bool (Default value is `$true`)
+Checks if a binary operator is surrounded on both sides by a space. E.g. `$x = 1`.
+
+#### CheckSeparator: bool (Default value is `$true`)
+Checks if a comma or a semicolon is followed by a space. E.g. `@(1, 2, 3)` or `@{a = 1; b = 2}`.

Rules/ScriptAnalyzerBuiltinRules.csproj

@@ -120,6 +120,7 @@
     <Compile Include="PlaceOpenBrace.cs" />
     <Compile Include="PlaceCloseBrace.cs" />
     <Compile Include="UseConsistentIndentation.cs" />
+    <Compile Include="UseConsistentWhitespace.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Engine\ScriptAnalyzerEngine.csproj">

Rules/Strings.resx

@@ -915,4 +915,28 @@
   <data name="UseConsistentIndentationError" xml:space="preserve">
     <value>Indentation not consistent</value>
   </data>
+  <data name="UseConsistentWhitespaceName" xml:space="preserve">
+    <value>UseConsistentWhitespace</value>
+  </data>
+  <data name="UseConsistentWhitespaceCommonName" xml:space="preserve">
+    <value>Use whitespaces</value>
+  </data>
+  <data name="UseConsistentWhitespaceDescription" xml:space="preserve">
+    <value>Check for whitespace between keyword and open paren/curly, around assigment operator ('='), around arithmetic operators and after separators (',' and ';')</value>
+  </data>
+  <data name="UseConsistentWhitespaceErrorBeforeBrace" xml:space="preserve">
+    <value>Use space before open brace.</value>
+  </data>
+  <data name="UseConsistentWhitespaceErrorBeforeParen" xml:space="preserve">
+    <value>Use space before open parenthesis.</value>
+  </data>
+  <data name="UseConsistentWhitespaceErrorOperator" xml:space="preserve">
+    <value>Use space before and after binary and assignment operators.</value>
+  </data>
+  <data name="UseConsistentWhitespaceErrorSeparatorComma" xml:space="preserve">
+    <value>Use space after a comma.</value>
+  </data>
+  <data name="UseConsistentWhitespaceErrorSeparatorSemi" xml:space="preserve">
+    <value>Use space after a semicolon.</value>
+  </data>
 </root>