Merge branch 'development' into AddSuggestedCorrections

Conflicts:
	Engine/Generic/DiagnosticRecord.cs
	Engine/Helper.cs

* Fix the merge conflict
* Handle scriptblock inputs for getting correction extents. Creating a CorrectionExtent instance would throw a null argument exception when filename is null, i.e., for scriptblock input

Author: Kapil Borle

Engine/Generic/DiagnosticRecord.cs

@@ -10,6 +10,9 @@
 // THE SOFTWARE.
 //
 
+
+
+using System;
 using System.Collections.Generic;
 using System.Management.Automation.Language;
 
@@ -25,7 +28,7 @@ public class DiagnosticRecord
         private IScriptExtent extent;
         private string ruleName;
         private DiagnosticSeverity severity;
-        private string scriptName;
+        private string scriptPath;
         private string ruleSuppressionId;
         private List<CorrectionExtent> suggestedCorrections;
 
@@ -35,7 +38,7 @@ public class DiagnosticRecord
         public string Message
         {
             get { return message; }
-            set { message = value; }
+            protected set { message = string.IsNullOrEmpty(value) ? string.Empty : value; }
         }
 
         /// <summary>
@@ -44,7 +47,7 @@ public string Message
         public IScriptExtent Extent
         {
             get { return extent; }
-            set { extent = value; }
+            protected set { extent = value; }
         }
 
         /// <summary>
@@ -53,7 +56,7 @@ public IScriptExtent Extent
         public string RuleName
         {
             get { return ruleName; }
-            set { ruleName = value; }
+            protected set { ruleName = string.IsNullOrEmpty(value) ? string.Empty : value; }
         }
 
         /// <summary>
@@ -70,18 +73,16 @@ public DiagnosticSeverity Severity
         /// </summary>
         public string ScriptName
         {
-            get { return scriptName; }
-            //Trim down to the leaf element of the filePath and pass it to Diagnostic Record
-            set {
-                if (!string.IsNullOrWhiteSpace(value))
-                {
-                    scriptName = System.IO.Path.GetFileName(value);
-                }
-                else
-                {
-                    scriptName = string.Empty;
-                }
-            }
+            get { return string.IsNullOrEmpty(scriptPath) ? string.Empty : System.IO.Path.GetFileName(scriptPath);}
+        }
+
+        /// <summary>
+        /// Returns the path of the script.
+        /// </summary>
+        public string ScriptPath
+        {
+            get { return scriptPath; }
+            protected set { scriptPath = string.IsNullOrEmpty(value) ? string.Empty : value; }
         }
 
         /// <summary>
@@ -117,18 +118,19 @@ public DiagnosticRecord()
         /// <param name="extent">The place in the script this diagnostic refers to</param>
         /// <param name="ruleName">The name of the rule that created this diagnostic</param>
         /// <param name="severity">The severity of this diagnostic</param>
-        /// <param name="scriptName">The name of the script file being analyzed</param>
+        /// <param name="scriptPath">The full path of the script file being analyzed</param>
         /// <param name="suggestedCorrections">The correction suggested by the rule to replace the extent text</param>
-        public DiagnosticRecord(string message, IScriptExtent extent, string ruleName, DiagnosticSeverity severity, string scriptName, string ruleId = null, List<CorrectionExtent> suggestedCorrections = null)
+        public DiagnosticRecord(string message, IScriptExtent extent, string ruleName, DiagnosticSeverity severity, string scriptPath, string ruleId = null, List<CorrectionExtent> suggestedCorrections = null)
         {
-            Message = string.IsNullOrEmpty(message) ? string.Empty : message;
-            RuleName = string.IsNullOrEmpty(ruleName) ? string.Empty : ruleName;
-            Extent = extent;
+            Message  = message;
+            RuleName = ruleName;
+            Extent   = extent;
             Severity = severity;
-            ScriptName = string.IsNullOrEmpty(scriptName) ? string.Empty : scriptName;
-            ruleSuppressionId = ruleId;
+            ScriptPath = scriptPath;
+            RuleSuppressionID = ruleId;
             this.suggestedCorrections = suggestedCorrections;
         }
+
     }
 
 

Engine/Generic/SuppressedRecord.cs

@@ -40,7 +40,7 @@ public SuppressedRecord(DiagnosticRecord record, RuleSuppression suppression)
                 Message = record.Message;
                 Extent = record.Extent;
                 Severity = record.Severity;
-                ScriptName = record.ScriptName;
+                ScriptPath = record.ScriptPath;
                 RuleSuppressionID = record.RuleSuppressionID;
             }
         }

Engine/Helper.cs

@@ -712,22 +712,30 @@ public IScriptExtent GetScriptExtentForFunctionName(FunctionDefinitionAst functi
             if (null == functionDefinitionAst)
             {
                 return null;
-            }
-
-            // Obtain the index where the function name is in Tokens
-            int funcTokenIndex = Tokens.Select((s, index) => new { s, index })
-                          .Where(x => x.s.Extent.StartOffset == functionDefinitionAst.Extent.StartOffset)
-                          .Select(x => x.index).FirstOrDefault();
+            }            
+            var funcNameTokens = Tokens.Where(
+                token => 
+                ContainsExtent(functionDefinitionAst.Extent, token.Extent) 
+                && token.Text.Equals(functionDefinitionAst.Name));
+            var funcNameToken = funcNameTokens.FirstOrDefault();
+            return funcNameToken == null ? null : funcNameToken.Extent;
+        }
 
-            if (funcTokenIndex > 0 && funcTokenIndex < Helper.Instance.Tokens.Count())
+        /// <summary>
+        /// Return true if subset is contained in set
+        /// </summary>
+        /// <param name="set"></param>
+        /// <param name="subset"></param>
+        /// <returns>True or False</returns>
+        private bool ContainsExtent(IScriptExtent set, IScriptExtent subset)
+        {
+            if (set == null || subset == null)
             {
-                // return the extent of the next token - this is the extent for the function name
-                return Tokens[++funcTokenIndex].Extent;
+                return false;
             }
-
-            return null;
+            return set.StartOffset <= subset.StartOffset
+                && set.EndOffset >= subset.EndOffset;
         }
-        
         private void FindClosingParenthesis(string keyword)
         {
             if (Tokens == null || Tokens.Length == 0)
@@ -1246,12 +1254,16 @@ internal List<RuleSuppression> GetSuppressionsClass(TypeDefinitionAst typeAst)
         /// </summary>
         /// <param name="ruleSuppressions"></param>
         /// <param name="diagnostics"></param>
-        public Tuple<List<SuppressedRecord>, List<DiagnosticRecord>> SuppressRule(string ruleName, Dictionary<string, List<RuleSuppression>> ruleSuppressionsDict, List<DiagnosticRecord> diagnostics)
+        public Tuple<List<SuppressedRecord>, List<DiagnosticRecord>> SuppressRule(
+            string ruleName,
+            Dictionary<string, List<RuleSuppression>> ruleSuppressionsDict,
+            List<DiagnosticRecord> diagnostics,
+            out List<ErrorRecord> errorRecords)
         {
             List<SuppressedRecord> suppressedRecords = new List<SuppressedRecord>();
             List<DiagnosticRecord> unSuppressedRecords = new List<DiagnosticRecord>();
             Tuple<List<SuppressedRecord>, List<DiagnosticRecord>> result = Tuple.Create(suppressedRecords, unSuppressedRecords);
-
+            errorRecords = new List<ErrorRecord>();
             if (diagnostics == null || diagnostics.Count == 0)
             {
                 return result;
@@ -1317,8 +1329,8 @@ public Tuple<List<SuppressedRecord>, List<DiagnosticRecord>> SuppressRule(string
                         ruleSuppression.Error = String.Format(CultureInfo.CurrentCulture, Strings.RuleSuppressionErrorFormat, ruleSuppression.StartAttributeLine,
                                 System.IO.Path.GetFileName(diagnostics.First().Extent.File), String.Format(Strings.RuleSuppressionIDError, ruleSuppression.RuleSuppressionID));
                     }
-
-                    this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(ruleSuppression.Error), ruleSuppression.Error, ErrorCategory.InvalidArgument, ruleSuppression));
+                    errorRecords.Add(new ErrorRecord(new ArgumentException(ruleSuppression.Error), ruleSuppression.Error, ErrorCategory.InvalidArgument, ruleSuppression));
+                    //this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(ruleSuppression.Error), ruleSuppression.Error, ErrorCategory.InvalidArgument, ruleSuppression));
                 }
             }
 
@@ -1372,6 +1384,135 @@ public static string[] ProcessCustomRulePaths(string[] rulePaths, SessionState s
             return outPaths.ToArray();
 
         }
+        
+        /// <summary>
+        /// Check if the function name starts with one of potentailly state changing verbs
+        /// </summary>
+        /// <param name="functionName"></param>
+        /// <returns>true if the function name starts with a state changing verb, otherwise false</returns>
+        public bool IsStateChangingFunctionName(string functionName)
+        {
+            if (functionName == null)
+            {
+                throw new ArgumentNullException("functionName");
+            }
+            // Array of verbs that can potentially change the state of a system
+            string[] stateChangingVerbs =
+            {
+                "Restart-",
+                "Stop-",
+                "New-",
+                "Set-",
+                "Update-",
+                "Reset-",
+                "Remove-"
+            };
+            foreach (var verb in stateChangingVerbs)
+            {
+                if (functionName.StartsWith(verb, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Get the SupportShouldProcess attribute ast
+        /// </summary>
+        /// <param name="attributeAsts"></param>
+        /// <returns>Returns SupportShouldProcess attribute ast if it exists, otherwise returns null</returns>
+        public NamedAttributeArgumentAst GetShouldProcessAttributeAst(IEnumerable<AttributeAst> attributeAsts)
+        {
+            if (attributeAsts == null)
+            {
+                throw new ArgumentNullException("attributeAsts");
+            }
+            var cmdletBindingAttributeAst = this.GetCmdletBindingAttributeAst(attributeAsts);
+            if (cmdletBindingAttributeAst == null
+                || cmdletBindingAttributeAst.NamedArguments == null)
+            {
+                return null;
+            }
+            foreach (var namedAttributeAst in cmdletBindingAttributeAst.NamedArguments)
+            {
+                if (namedAttributeAst != null
+                    && namedAttributeAst.ArgumentName.Equals(
+                        "SupportsShouldProcess",
+                        StringComparison.OrdinalIgnoreCase))
+                {
+                    return namedAttributeAst;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get the CmdletBinding attribute ast
+        /// </summary>
+        /// <param name="attributeAsts"></param>
+        /// <returns>Returns CmdletBinding attribute ast if it exists, otherwise returns null</returns>
+        public AttributeAst GetCmdletBindingAttributeAst(IEnumerable<AttributeAst> attributeAsts)
+        {
+            if (attributeAsts == null)
+            {
+                throw new ArgumentNullException("attributeAsts");
+            }
+            foreach (var attributeAst in attributeAsts)
+            {
+                if (attributeAst == null || attributeAst.NamedArguments == null)
+                {
+                    continue;
+                }
+                if (attributeAst.TypeName.GetReflectionAttributeType()
+                    == typeof(CmdletBindingAttribute))
+                {
+                    return attributeAst;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get the boolean value of the named attribute argument
+        /// </summary>
+        /// <param name="namedAttributeArgumentAst"></param>
+        /// <returns>Boolean value of the named attribute argument</returns>
+        public bool GetNamedArgumentAttributeValue(NamedAttributeArgumentAst namedAttributeArgumentAst)
+        {
+            if (namedAttributeArgumentAst == null)
+            {
+                throw new ArgumentNullException("namedAttributeArgumentAst");
+            }
+            if (namedAttributeArgumentAst.ExpressionOmitted)
+            {
+                return true;
+            }
+            else
+            {
+                var varExpAst = namedAttributeArgumentAst.Argument as VariableExpressionAst;
+                if (varExpAst == null)
+                {
+                    var constExpAst = namedAttributeArgumentAst.Argument as ConstantExpressionAst;
+                    if (constExpAst == null)
+                    {
+                        return false;
+                    }
+                    bool constExpVal;
+                    if (LanguagePrimitives.TryConvertTo<bool>(constExpAst.Value, out constExpVal))
+                    {
+                        return constExpVal;
+                    }
+                }
+                else
+                {
+                    return varExpAst.VariablePath.UserPath.Equals(
+                        bool.TrueString,
+                        StringComparison.OrdinalIgnoreCase);
+                }
+            }
+            return false;
+        }
 
         #endregion Methods
     }