Apply suggestions from code review

Co-authored-by: Robert Holt <[email protected]>

Author: Jaykul

RuleDocumentation/UseConsistentCasing.md

@@ -4,7 +4,12 @@
 
 ## Description
 
-This is a style/formatting rule. PowerShell is case insensitive where applicable. The casing of keywords and operators does not matter but this rule ensures the use of lowercase for consistency and also because it helps distinguish keywords from commands (e.g. `foreach` is a keyword, but `ForEach-Object` is the command) and parameters (which should start with a capital letter).
+Prescribes lowercase characters for PowerShell keywords and operators.
+PowerShell is case-insensitive for keywords and operators,
+however maintaining a single casing convention aids consistency,
+and using lowercase helps to distinguish keywords from commands
+and operators from parameters.
+For example, this rule ensures the keyword `foreach` is distinguishable from the `ForEach-Object` command.
 
 ## How
 

Rules/Strings.resx

@@ -1167,4 +1167,4 @@
   <data name="InvalidSyntaxAroundProcessBlockError" xml:space="preserve">
     <value>When using an explicit process block, no preceding code is allowed, only begin, end and dynamicparams blocks.</value>
   </data>
-</root>
+</root>

Rules/UseConsistentCasing.cs

@@ -20,15 +20,14 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
 #if !CORECLR
     [Export(typeof(IScriptRule))]
 #endif
-
     public class UseConsistentCasing : ConfigurableRule
     {
         /// <summary>If true, require the case of all operators to match the specified casing.</summary>
-        [ConfigurableRuleProperty(defaultValue: "true")]
+        [ConfigurableRuleProperty(defaultValue: true)]
         public bool CheckOperator { get; set; }
 
         /// <summary>If true, require the case of all keywords to match the specified casing.</summary>
-        [ConfigurableRuleProperty(defaultValue: "true")]
+        [ConfigurableRuleProperty(defaultValue: true)]
         public bool CheckKeyword { get; set; }
 
         /*
@@ -60,7 +59,10 @@ public string Case
         /// </summary>
         public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
         {
-            if (ast == null) throw new ArgumentNullException(Strings.NullAstErrorMessage);
+            if (ast is null)
+            {
+                throw new ArgumentNullException(Strings.NullAstErrorMessage);
+            }
 
             Token[] tokens;
             ParseError[] errors;
@@ -70,10 +72,17 @@ public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string file
                 Parser.ParseInput(ast.Extent.Text, out tokens, out errors);
 
                 // Iterates all keywords and check the case
-                foreach (Token keyword in tokens.Where(t => t.TokenFlags.HasFlag(TokenFlags.Keyword)))
+                for (int i = 0; i < Helper.Tokens.Length; i++)
                 {
-                    string correctCase = keyword.Text.ToLowerInvariant();
-                    if (!keyword.Text.Equals(correctCase, StringComparison.Ordinal))
+                    Token currToken = Helper.Tokens[i];
+                    
+                    if ((currToken.TokenFlags & TokenFlags.Keyword) == 0)
+                    {
+                        continue;
+                    }
+                    
+                    string correctCase = currToken.Text.ToLowerInvariant();
+                    if (!currToken.Text.Equals(correctCase, StringComparison.Ordinal))
                     {
                         yield return GetDiagnosticRecord(keyword, fileName, correctCase);
                     }
@@ -85,39 +94,42 @@ public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string file
                 foreach (ExpressionAst oper in ast.FindAll(a => a is UnaryExpressionAst || a is BinaryExpressionAst, true))
                 {
                     // but handle them separately
-                    UnaryExpressionAst unary = oper as UnaryExpressionAst;
-                    if (unary != null) {
-                        string correctCase = "-" + unary.TokenKind.ToString().ToLowerInvariant();
-                        string actualCase = unary.Extent.Text.Substring(0, correctCase.Length);
-                        if (!actualCase.Equals(correctCase, StringComparison.Ordinal))
-                        {
-                            yield return GetDiagnosticRecord(unary, fileName, correctCase);
-                        }
-                    }
-                    else
+                    switch (oper)
                     {
-                        BinaryExpressionAst binary = oper as BinaryExpressionAst;
-                        string correctCase = binary.ErrorPosition.Text.ToLowerInvariant();
-                        if (!binary.ErrorPosition.Text.Equals(correctCase, StringComparison.Ordinal))
-                        {
-                            yield return GetDiagnosticRecord(binary, fileName, correctCase);
-                        }
+                        case UnaryExpressionAst unary:
+                            string correctCase = "-" + unary.TokenKind.ToString().ToLowerInvariant();
+                            string actualCase = unary.Extent.Text.Substring(0, correctCase.Length);
+                            if (!actualCase.Equals(correctCase, StringComparison.Ordinal))
+                            {
+                                yield return GetDiagnosticRecord(unary, fileName, correctCase);
+                            }
+                            continue;
+
+                        case BinaryExpressionAst binary:
+                            string correctCase = binary.ErrorPosition.Text.ToLowerInvariant();
+                            if (!binary.ErrorPosition.Text.Equals(correctCase, StringComparison.Ordinal))
+                            {
+                                yield return GetDiagnosticRecord(binary, fileName, correctCase);
+                            }
+                            continue;
                     }
                 }
             }
         }
 
         private DiagnosticRecord GetDiagnosticRecord(Token token, string fileName, string correction)
         {
-            var extents = new CorrectionExtent[] {
+            var extents = new[]
+            {
                 new CorrectionExtent(
                     token.Extent.StartLineNumber,
                     token.Extent.EndLineNumber,
                     token.Extent.StartColumnNumber,
                     token.Extent.EndColumnNumber,
                     correction,
                     token.Extent.File,
-                    GetDescription())};
+                    GetDescription())
+            };
 
             return new DiagnosticRecord(
                 string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentCasingKeywordError, token.Text, correction),