Add support for rule suppression id with uninitializedvariable

Author: Quoc Truong

Engine/Commands/InvokeScriptAnalyzerCommand.cs

@@ -292,7 +292,7 @@ private void AnalyzeFile(string filePath)
                 return;
             }
 
-            Dictionary<string, LinkedList<Tuple<int, int>>> ruleSuppressions = Helper.Instance.GetRuleSuppression(ast);
+            Dictionary<string, List<RuleSuppression>> ruleSuppressions = Helper.Instance.GetRuleSuppression(ast);
 
             #region Run VariableAnalysis
             try
@@ -324,7 +324,7 @@ private void AnalyzeFile(string filePath)
                         }
                         catch (Exception scriptRuleException)
                         {
-                            WriteError(new ErrorRecord(scriptRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, filePath));
+                            WriteError(new ErrorRecord(scriptRuleException, Strings.RuleErrorMessage, ErrorCategory.InvalidOperation, filePath));
                             continue;
                         }
                     }
@@ -385,7 +385,7 @@ private void AnalyzeFile(string filePath)
                             }
                             catch (Exception commandRuleException)
                             {
-                                WriteError(new ErrorRecord(commandRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, fileName));
+                                WriteError(new ErrorRecord(commandRuleException, Strings.RuleErrorMessage, ErrorCategory.InvalidOperation, fileName));
                                 continue;
                             }  
                         }
@@ -414,7 +414,7 @@ private void AnalyzeFile(string filePath)
                         }
                         catch (Exception tokenRuleException)
                         {
-                            WriteError(new ErrorRecord(tokenRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, fileName));
+                            WriteError(new ErrorRecord(tokenRuleException, Strings.RuleErrorMessage, ErrorCategory.InvalidOperation, fileName));
                             continue;
                         } 
                     }
@@ -442,7 +442,7 @@ private void AnalyzeFile(string filePath)
                         }
                         catch (Exception dscResourceRuleException)
                         {
-                            WriteError(new ErrorRecord(dscResourceRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, filePath));
+                            WriteError(new ErrorRecord(dscResourceRuleException, Strings.RuleErrorMessage, ErrorCategory.InvalidOperation, filePath));
                             continue;
                         }    
                     }
@@ -484,7 +484,7 @@ private void AnalyzeFile(string filePath)
                                             }
                                             catch (Exception dscResourceRuleException)
                                             {
-                                                WriteError(new ErrorRecord(dscResourceRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, filePath));
+                                                WriteError(new ErrorRecord(dscResourceRuleException, Strings.RuleErrorMessage, ErrorCategory.InvalidOperation, filePath));
                                                 continue;
                                             }  
                                         }
@@ -519,7 +519,7 @@ private void AnalyzeFile(string filePath)
                         }
                         catch (Exception externalRuleException)
                         {
-                            WriteError(new ErrorRecord(externalRuleException, Strings.RuleError, ErrorCategory.InvalidOperation, fileName));
+                            WriteError(new ErrorRecord(externalRuleException, Strings.RuleErrorMessage, ErrorCategory.InvalidOperation, fileName));
                         }
                     }
                 }

Engine/Generic/RuleSuppression.cs

@@ -13,7 +13,7 @@ public class RuleSuppression
         /// <summary>
         /// The start offset of the rule suppression
         /// </summary>
-        public int StartOffSet
+        public int StartOffset
         {
             get;
             set;
@@ -79,7 +79,7 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
 
                     if (positionalArguments.Any(item => !(item is StringConstantExpressionAst)))
                     {
-                        Error = "All the arguments of the suppression message attribute should be string constant";
+                        Error = Strings.StringConstantArgumentsSuppressionAttributeError;
                     }
                     else
                     {
@@ -105,12 +105,12 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
                     {
                         if (name.Extent.StartOffset < lastPositionalArgumentsOffset)
                         {
-                            Error = "Named arguments must always come after positional arguments";
+                            Error = Strings.NamedArgumentsBeforePositionalError;
                             break;
                         }
                         else if (!(name.Argument is StringConstantExpressionAst))
                         {
-                            Error = "All the arguments of the suppression message attribute should be string constant";
+                            Error = Strings.StringConstantArgumentsSuppressionAttributeError;
                             break;
                         }
 
@@ -119,7 +119,7 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
                             case "rulename":
                                 if (!String.IsNullOrWhiteSpace(RuleName))
                                 {
-                                    Error = "RuleName cannot be set by both positional and named arguments";
+                                    Error = String.Format(Strings.NamedAndPositionalArgumentsConflictError, name);
                                 }
 
                                 RuleName = (name.Argument as StringConstantExpressionAst).Value;
@@ -128,7 +128,7 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
                             case "rulesuppressionid":
                                 if (!String.IsNullOrWhiteSpace(RuleSuppressionID))
                                 {
-                                    Error = "RuleSuppressionID cannot be set by both positional and named arguments";
+                                    Error = String.Format(Strings.NamedAndPositionalArgumentsConflictError, name);
                                 }
 
                                 RuleSuppressionID = (name.Argument as StringConstantExpressionAst).Value;
@@ -141,7 +141,7 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
                 }
             }
 
-            StartOffSet = start;
+            StartOffset = start;
             EndOffset = end;
         }
 

Engine/Helper.cs

@@ -612,7 +612,7 @@ public bool HasSpecialVars(string varName)
         /// </summary>
         /// <param name="ast"></param>
         /// <returns></returns>
-        public Dictionary<string, LinkedList<Tuple<int, int>>> GetRuleSuppression(Ast ast)
+        public Dictionary<string, List<RuleSuppression>> GetRuleSuppression(Ast ast)
         {
             List<RuleSuppression> ruleSuppressionList = new List<RuleSuppression>();
 
@@ -632,39 +632,18 @@ public Dictionary<string, LinkedList<Tuple<int, int>>> GetRuleSuppression(Ast as
                 ruleSuppressionList.AddRange(GetSuppressionsClass(typeAst));
             }
 
-            Dictionary<string, LinkedList<Tuple<int, int>>> results = new Dictionary<string, LinkedList<Tuple<int, int>>>(StringComparer.OrdinalIgnoreCase);
-            ruleSuppressionList.Sort((item, item2) => item.StartOffSet.CompareTo(item2.StartOffSet));
+            Dictionary<string, List<RuleSuppression>> results = new Dictionary<string, List<RuleSuppression>>(StringComparer.OrdinalIgnoreCase);
+            ruleSuppressionList.Sort((item, item2) => item.StartOffset.CompareTo(item2.StartOffset));
 
             foreach (RuleSuppression ruleSuppression in ruleSuppressionList)
             {
                 if (!results.ContainsKey(ruleSuppression.RuleName))
                 {
-                    LinkedList<Tuple<int, int>> intervals = new LinkedList<Tuple<int, int>>();
-                    intervals.AddLast(Tuple.Create(ruleSuppression.StartOffSet, ruleSuppression.EndOffset));
-                    results.Add(ruleSuppression.RuleName, intervals);
-                }
-                else
-                {
-                    LinkedList<Tuple<int, int>> intervals = results[ruleSuppression.RuleName];
-                    int previousEnd = intervals.Last.Value.Item2;
-
-                    // proccess the intervals so they do not overlap and is sorted in order
-                    if (ruleSuppression.StartOffSet <= previousEnd)
-                    {
-                        if (ruleSuppression.EndOffset <= previousEnd)
-                        {
-                            continue;
-                        }
-                        else
-                        {
-                            intervals.Last.Value = Tuple.Create(intervals.Last.Value.Item1, ruleSuppression.EndOffset);
-                        }
-                    }
-                    else
-                    {
-                        intervals.AddLast(Tuple.Create(ruleSuppression.StartOffSet, ruleSuppression.EndOffset));
-                    }
+                    List<RuleSuppression> ruleSuppressions = new List<RuleSuppression>();
+                    results.Add(ruleSuppression.RuleName, ruleSuppressions);
                 }
+                
+                results[ruleSuppression.RuleName].Add(ruleSuppression);
             }
 
             return results;
@@ -727,59 +706,62 @@ internal List<RuleSuppression> GetSuppressionsClass(TypeDefinitionAst typeAst)
         /// </summary>
         /// <param name="ruleSuppressions"></param>
         /// <param name="diagnostics"></param>
-        public List<DiagnosticRecord> SuppressRule(string ruleName, Dictionary<string, LinkedList<Tuple<int, int>>> ruleSuppressions, List<DiagnosticRecord> diagnostics)
+        public List<DiagnosticRecord> SuppressRule(string ruleName, Dictionary<string, List<RuleSuppression>> ruleSuppressionsDict, List<DiagnosticRecord> diagnostics)
         {
             List<DiagnosticRecord> results = new List<DiagnosticRecord>();
-            if (!ruleSuppressions.ContainsKey(ruleName) || diagnostics.Count == 0)
+
+            if (!ruleSuppressionsDict.ContainsKey(ruleName) || diagnostics.Count == 0)
             {
                 return diagnostics;
             }
 
-            LinkedList<Tuple<int, int>> intervals = ruleSuppressions[ruleName];
+            List<RuleSuppression> ruleSuppressions = ruleSuppressionsDict[ruleName];
 
-            if (intervals.Count == 0)
+            if (ruleSuppressions.Count == 0)
             {
                 return diagnostics;
             }
 
             int recordIndex = 0;
+            int ruleSuppressionIndex = 0;
             DiagnosticRecord record = diagnostics.First();
-            LinkedListNode<Tuple<int, int>> interval = intervals.First;
+            RuleSuppression ruleSuppression = ruleSuppressions.First();
 
             while (recordIndex < diagnostics.Count)
             {
-                // the record precedes the interval so don't apply the suppression
-                if (record.Extent.StartOffset < interval.Value.Item1)
+                // the record precedes the rule suppression so don't apply the suppression
+                if (record.Extent.StartOffset < ruleSuppression.StartOffset)
                 {
                     results.Add(record);
-                    recordIndex += 1;
-
-                    if (recordIndex == diagnostics.Count)
-                    {
-                        break;
-                    }
-                    else
-                    {
-                        // move on to the next record
-                        record = diagnostics[recordIndex];
-                        continue;
-                    }
                 }
-
-                // end of the rule suppression is less than the record start offset so move on to next interval
-                if (interval.Value.Item2 < record.Extent.StartOffset)
+                // end of the rule suppression is less than the record start offset so move on to next rule suppression
+                else if (ruleSuppression.EndOffset < record.Extent.StartOffset)
                 {
-                    interval = interval.Next;
+                    ruleSuppressionIndex += 1;
 
-                    if (interval == null)
+                    if (ruleSuppressionIndex == ruleSuppressions.Count)
                     {
                         break;
                     }
 
+                    ruleSuppression = ruleSuppressions[ruleSuppressionIndex];
+
                     continue;
                 }
+                // at this point, the record is inside the interval
+                else
+                {
+                    // if the rule suppression id from the rule suppression is not null and the one from diagnostic record is not null
+                    // and they are they are not the same then we cannot ignore the record
+                    if (!string.IsNullOrWhiteSpace(ruleSuppression.RuleSuppressionID) && !string.IsNullOrWhiteSpace(record.RuleSuppressionID)
+                        && !string.Equals(ruleSuppression.RuleSuppressionID, record.RuleSuppressionID, StringComparison.OrdinalIgnoreCase))
+                    {
+                        results.Add(record);
+                    }
+                    // otherwise, we ignore the record, move on to the next.
+                }
 
-                // here the record is inside the interval so we don't add it to the result
+                // important assumption: this point is reached only if we want to move to the next record
                 recordIndex += 1;
 
                 if (recordIndex == diagnostics.Count)

Engine/ScriptAnalyzerEngine.csproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -71,7 +71,7 @@
     <Compile Include="Loggers\WriteObjectsLogger.cs" />
     <Compile Include="ScriptAnalyzer.cs" />
     <Compile Include="SpecialVars.cs" />
-    <Compile Include="Strings.cs">
+    <Compile Include="Strings.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
       <DependentUpon>Strings.resx</DependentUpon>
@@ -87,7 +87,7 @@
   <ItemGroup>
     <EmbeddedResource Include="Strings.resx">
       <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Strings.cs</LastGenOutput>
+      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSHARP.Targets" />
@@ -100,4 +100,4 @@ copy /y "$(ProjectDir)\*.ps1xml" "$(SolutionDir)$(SolutionName)"
 copy /y "$(ProjectDir)\*.psd1" "$(SolutionDir)$(SolutionName)"
 copy /y "$(TargetPath)" "$(SolutionDir)$(SolutionName)"</PostBuildEvent>
   </PropertyGroup>
-</Project>
+</Project>