Add rule suppression for classes and functions in classes

Author: Quoc Truong

Engine/Generic/RuleSuppression.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Management.Automation.Language;
+using System.Collections.Generic;
 
 namespace Microsoft.Windows.Powershell.ScriptAnalyzer.Generic
 {
@@ -143,5 +144,38 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
             StartOffSet = start;
             EndOffset = end;
         }
+
+        /// <summary>
+        /// Given a list of attribute asts, return a list of rule suppression
+        /// with startoffset at start and endoffset at end
+        /// </summary>
+        /// <param name="attrAsts"></param>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <returns></returns>
+        public static List<RuleSuppression> GetSuppressions(IEnumerable<AttributeAst> attrAsts, int start, int end)
+        {
+            List<RuleSuppression> result = new List<RuleSuppression>();
+
+            if (attrAsts == null)
+            {
+                return result;
+            }
+
+            IEnumerable<AttributeAst> suppressionAttribute = attrAsts.Where(
+                item => item.TypeName.GetReflectionType() == typeof(System.Diagnostics.CodeAnalysis.SuppressMessageAttribute));
+
+            foreach (var attributeAst in suppressionAttribute)
+            {
+                RuleSuppression ruleSupp = new RuleSuppression(attributeAst, start, end);
+
+                if (string.IsNullOrWhiteSpace(ruleSupp.Error))
+                {
+                    result.Add(ruleSupp);
+                }
+            }
+
+            return result;
+        }
     }
 }

Engine/Helper.cs

@@ -615,10 +615,21 @@ public bool HasSpecialVars(string varName)
         public Dictionary<string, LinkedList<Tuple<int, int>>> GetRuleSuppression(Ast ast)
         {
             List<RuleSuppression> ruleSuppressionList = new List<RuleSuppression>();
+            
+            // Get rule suppression from functions
             IEnumerable<FunctionDefinitionAst> funcAsts = ast.FindAll(item => item is FunctionDefinitionAst, true).Cast<FunctionDefinitionAst>();
+
             foreach (var funcAst in funcAsts)
             {
-                ruleSuppressionList.AddRange(GetSuppressionFunction(funcAst));
+                ruleSuppressionList.AddRange(GetSuppressionsFunction(funcAst));
+            }
+
+            // Get rule suppression from classes
+            IEnumerable<TypeDefinitionAst> typeAsts = ast.FindAll(item => item is TypeDefinitionAst, true).Cast<TypeDefinitionAst>();
+
+            foreach (var typeAst in typeAsts)
+            {
+                ruleSuppressionList.AddRange(GetSuppressionsClass(typeAst));
             }
 
             Dictionary<string, LinkedList<Tuple<int, int>>> results = new Dictionary<string, LinkedList<Tuple<int, int>>>(StringComparer.OrdinalIgnoreCase);
@@ -664,24 +675,48 @@ public Dictionary<string, LinkedList<Tuple<int, int>>> GetRuleSuppression(Ast as
         /// </summary>
         /// <param name="funcAst"></param>
         /// <returns></returns>
-        internal List<RuleSuppression> GetSuppressionFunction(FunctionDefinitionAst funcAst)
+        internal List<RuleSuppression> GetSuppressionsFunction(FunctionDefinitionAst funcAst)
         {
             List<RuleSuppression> result = new List<RuleSuppression>();
 
             if (funcAst != null && funcAst.Body != null
                 && funcAst.Body.ParamBlock != null && funcAst.Body.ParamBlock.Attributes != null)
             {
-                IEnumerable<AttributeAst> suppressionAttribute = funcAst.Body.ParamBlock.Attributes.Where(
-                    item => item.TypeName.GetReflectionType() == typeof(System.Diagnostics.CodeAnalysis.SuppressMessageAttribute));
+                result.AddRange(RuleSuppression.GetSuppressions(funcAst.Body.ParamBlock.Attributes, funcAst.Extent.StartOffset, funcAst.Extent.EndOffset));
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Returns a list of rule suppression from the class
+        /// </summary>
+        /// <param name="typeAst"></param>
+        /// <returns></returns>
+        internal List<RuleSuppression> GetSuppressionsClass(TypeDefinitionAst typeAst)
+        {
+            List<RuleSuppression> result = new List<RuleSuppression>();
+
+            if (typeAst != null && typeAst.Attributes != null && typeAst.Attributes.Count != 0)
+            {
+                result.AddRange(RuleSuppression.GetSuppressions(typeAst.Attributes, typeAst.Extent.StartOffset, typeAst.Extent.EndOffset));
+            }
 
-                foreach (var attributeAst in suppressionAttribute)
+            if (typeAst.Members == null)
+            {
+                return result;
+            }
+
+            foreach (var member in typeAst.Members)
+            {
+                FunctionMemberAst funcMemb = member as FunctionMemberAst;
+
+                if (funcMemb == null)
                 {
-                    RuleSuppression ruleSupp = new RuleSuppression(attributeAst, funcAst.Extent.StartOffset, funcAst.Extent.EndOffset);
-                    if (String.IsNullOrWhiteSpace(ruleSupp.Error))
-                    {
-                        result.Add(ruleSupp);
-                    }
+                    continue;
                 }
+
+                result.AddRange(RuleSuppression.GetSuppressions(funcMemb.Attributes, funcMemb.Extent.StartOffset, funcMemb.Extent.EndOffset));
             }
 
             return result;
@@ -844,6 +879,16 @@ public object VisitScriptBlock(ScriptBlockAst scriptBlockAst)
             return null;
         }
 
+        /// <summary>
+        /// Do nothing
+        /// </summary>
+        /// <param name="baseCtorInvokeMemberExpressionAst"></param>
+        /// <returns></returns>
+        public object VisitBaseCtorInvokeMemberExpression(BaseCtorInvokeMemberExpressionAst baseCtorInvokeMemberExpressionAst)
+        {
+            return null;
+        }
+
         /// <summary>
         /// Do nothing
         /// </summary>