Added -AutoFix switch on Invoke-ScriptAnalyzer for the 'File' ParameterSet and implement it for PSAvoidUsingCmdletAliases.

It uses the information available in the DiagnosticRecord class to fix the rule.

Author: bergmeister

Engine/Commands/InvokeScriptAnalyzerCommand.cs

@@ -42,7 +42,7 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.Commands
     public class InvokeScriptAnalyzerCommand : PSCmdlet, IOutputWriter
     {
         #region Private variables
-        List<string> processedPaths;
+        private List<string> processedPaths;
         #endregion // Private variables
 
         #region Parameters
@@ -117,6 +117,18 @@ public SwitchParameter IncludeDefaultRules
         }
         private bool includeDefaultRules;
 
+        /// <summary>
+        /// Resolves rule violations automatically where possible.
+        /// </summary>
+        [Parameter(Mandatory = false, ParameterSetName = "File")]
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public SwitchParameter AutoFix
+        {
+            get { return autoFix; }
+            set { autoFix = value; }
+        }
+        private bool autoFix;
+
         /// <summary>
         /// ExcludeRule: Array of names of rules to be disabled.
         /// </summary>
@@ -351,7 +363,7 @@ private void ProcessInput()
             {
                 foreach (var p in processedPaths)
                 {
-                    diagnosticsList = ScriptAnalyzer.Instance.AnalyzePath(p, this.recurse);
+                    diagnosticsList = ScriptAnalyzer.Instance.AnalyzePath(p, this.recurse, this.autoFix);
                     WriteToOutput(diagnosticsList);
                 }
             }

Engine/Generic/DiagnosticRecord.cs

@@ -14,7 +14,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Management.Automation.Language;
+using System.Security;
 
 namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic
 {
@@ -31,6 +34,7 @@ public class DiagnosticRecord
         private string scriptPath;
         private string ruleSuppressionId;
         private List<CorrectionExtent> suggestedCorrections;
+        private bool canBeFixedAutomatically;
 
         /// <summary>
         /// Represents a string from the rule about why this diagnostic was created.
@@ -73,7 +77,7 @@ public DiagnosticSeverity Severity
         /// </summary>
         public string ScriptName
         {
-            get { return string.IsNullOrEmpty(scriptPath) ? string.Empty : System.IO.Path.GetFileName(scriptPath);}
+            get { return string.IsNullOrEmpty(scriptPath) ? string.Empty : System.IO.Path.GetFileName(scriptPath); }
         }
 
         /// <summary>
@@ -103,6 +107,14 @@ public IEnumerable<CorrectionExtent> SuggestedCorrections
             get { return suggestedCorrections;  }            
         }
 
+        /// <summary>
+        /// Returns whether it can be corrected automatically using the <see cref="AutoFix"/> method or by using the '-Fix' switch of Invoke-Scriptanalyzer
+        /// </summary>
+        public bool CanBeFixedAutomatically
+        {
+            get { return canBeFixedAutomatically; }
+        }
+
         /// <summary>
         /// DiagnosticRecord: The constructor for DiagnosticRecord class.
         /// </summary>
@@ -120,20 +132,85 @@ public DiagnosticRecord()
         /// <param name="severity">The severity of this diagnostic</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 scriptPath, string ruleId = null, List<CorrectionExtent> suggestedCorrections = null)
+        /// <param name="canBeFixedAutomatically">Enough information is present in this object for an automatic if a scriptPath is present</param>
+        public DiagnosticRecord(string message, IScriptExtent extent, string ruleName, DiagnosticSeverity severity, string scriptPath, string ruleId = null, List<CorrectionExtent> suggestedCorrections = null, bool canBeFixedAutomatically = false)
         {
-            Message  = message;
+            Message = message;
             RuleName = ruleName;
-            Extent   = extent;
+            Extent = extent;
             Severity = severity;
             ScriptPath = scriptPath;
             RuleSuppressionID = ruleId;
             this.suggestedCorrections = suggestedCorrections;
+            this.canBeFixedAutomatically = canBeFixedAutomatically;
         }
 
+        /// <summary>
+        /// Uses the first element in the list SuggestedCorrections for the fix and replaces it with the Extentent.Text property
+        /// Only supported for files at the moment.
+        /// </summary>
+        internal void AutoFix()
+        {
+            if (!string.IsNullOrEmpty(this.scriptPath))
+            {
+                var textToBeReplaced = this.Extent.Text;
+                string textReplacement = this.SuggestedCorrections.FirstOrDefault().Text;
+
+                // Fix rule
+                var scriptPath = this.ScriptPath;
+                string[] originalLines = new string[] { };
+                try
+                {
+                    originalLines = File.ReadAllLines(scriptPath);
+                }
+                catch (Exception e)  // because the file was already read before, we do not expect errors and therefore it is not worth catching specifically
+                {
+                    Console.WriteLine($"Error reading file {scriptPath}. Exception: {e.Message}");
+                }
+                var lineNumber = this.SuggestedCorrections.FirstOrDefault().StartLineNumber;
+                originalLines[lineNumber - 1] = originalLines[lineNumber - 1].Remove(this.Extent.StartColumnNumber - 1, textToBeReplaced.Length);
+                originalLines[lineNumber - 1] = originalLines[lineNumber - 1].Insert(this.Extent.StartColumnNumber - 1, textReplacement);
+
+                var errorMessagePreFix = "Failed to apply AutoFix when writing to file " + scriptPath + Environment.NewLine;
+                // we need to catch all exceptions that could be thrown except for ArgumentException and ArgumentNullException because at this stage the file path has already been verified.
+                try
+                {
+                    Console.WriteLine($"AutoFix {this.RuleName} by replacing '{textToBeReplaced}' with '{textReplacement}' in line {lineNumber} of file {scriptPath}");
+                    File.WriteAllLines(scriptPath, originalLines);
+                }
+                catch (PathTooLongException)
+                {
+                    Console.WriteLine(errorMessagePreFix + "The specified path, file name, or both exceed the system - defined maximum length. " +
+                                      "For example, on Windows - based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.");
+                }
+                catch (DirectoryNotFoundException)
+                {
+                    Console.WriteLine(errorMessagePreFix + "The specified path is invalid (for example, it is on an unmapped drive).");
+                }
+                catch (IOException)
+                {
+                    Console.WriteLine(errorMessagePreFix + "An I/O error occurred while opening the file.");
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    Console.WriteLine(errorMessagePreFix + "Path specified a file that is read-only or this operation is not supported on the current platform or the caller does not have the required permission.");
+                }
+                catch (SecurityException)
+                {
+                    Console.WriteLine(errorMessagePreFix + "You do not have the required permission to write to the file.");
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(errorMessagePreFix + "Unexpected error:" + e.Message);
+                }
+            }
+            else
+            {
+                Console.WriteLine("AutoFix functionality currently only supported for files");
+            }
+        }
     }
 
-
     /// <summary>
     /// Represents a severity level of an issue.
     /// </summary>

Engine/ScriptAnalyzer.cs

@@ -1454,8 +1454,9 @@ public Dictionary<string, List<string>> CheckRuleExtension(string[] path, PathIn
         /// If true, recursively searches the given file path and analyzes any
         /// script files that are found.
         /// </param>
+        /// <param name="autoFix">Fix warnings that can be automatically fixed.</param>
         /// <returns>An enumeration of DiagnosticRecords that were found by rules.</returns>
-        public IEnumerable<DiagnosticRecord> AnalyzePath(string path, bool searchRecursively = false)
+        public IEnumerable<DiagnosticRecord> AnalyzePath(string path, bool searchRecursively = false, bool autoFix = false)
         {
             List<string> scriptFilePaths = new List<string>();
 
@@ -1477,13 +1478,41 @@ public IEnumerable<DiagnosticRecord> AnalyzePath(string path, bool searchRecursi
             {
                 // Yield each record in the result so that the
                 // caller can pull them one at a time
-                foreach (var diagnosticRecord in this.AnalyzeFile(scriptFilePath))
+                var diagnosticRecords = this.AnalyzeFile(scriptFilePath);
+                if(autoFix)
+                {
+                    bool allFixableWarningsFixed = false;
+                    while(!allFixableWarningsFixed)
+                    {
+                        allFixableWarningsFixed = !(AutoFixFirstFixableDiagnosticRecord(diagnosticRecords));
+                        diagnosticRecords = this.AnalyzeFile(scriptFilePath);  // update records with the correct line numbers after fix
+                    }
+                }
+                foreach (var diagnosticRecord in diagnosticRecords)
                 {
                     yield return diagnosticRecord;
                 }
             }
         }
 
+        /// <summary>
+        /// Fixes only the first fixable DiagnosticRecord that it encounters because afterwards the other records need to be re-created as their line/column numbers are different then
+        /// </summary>
+        /// <param name="diagnosticRecords"></param>
+        /// <returns>True if it could fix a warning</returns>
+        private bool AutoFixFirstFixableDiagnosticRecord(IEnumerable<DiagnosticRecord> diagnosticRecords)
+        {
+            foreach(var diagnosticRecord in diagnosticRecords)
+            {
+                if (diagnosticRecord.CanBeFixedAutomatically)
+                {
+                    diagnosticRecord.AutoFix();
+                    return true;
+                }
+            }
+            return false;
+        }
+
         /// <summary>
         /// Analyzes a script definition in the form of a string input
         /// </summary>

Rules/AvoidAlias.cs

@@ -135,7 +135,8 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                         DiagnosticSeverity.Warning,
                         fileName,
                         aliasName,
-                        suggestedCorrections: GetCorrectionExtent(cmdAst, cmdletName));
+                        suggestedCorrections: GetCorrectionExtent(cmdAst, cmdletName),
+                        canBeFixedAutomatically: true);
                 }
             }
         }