Add method to check executing PSVersion from Helper

Author: Kapil Borle

Engine/Commands/InvokeScriptAnalyzerCommand.cs

@@ -26,6 +26,7 @@
 using System.Collections.Concurrent;
 using System.Threading;
 using System.Management.Automation.Runspaces;
+using System.Collections;
 
 namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.Commands
 {
@@ -220,6 +221,12 @@ protected override void BeginProcessing()
                 this);
             Helper.Instance.Initialize();
 
+            var psVersionTable = this.SessionState.PSVariable.GetValue("PSVersionTable") as Hashtable;
+            if (psVersionTable != null)
+            {
+                Helper.Instance.SetPSVersionTable(psVersionTable);
+            }
+
             string[] rulePaths = Helper.ProcessCustomRulePaths(customRulePath,
                 this.SessionState, recurseCustomRulePath);
             if (IsFileParameterSet())

Engine/Helper.cs

@@ -20,6 +20,7 @@
 using System.Globalization;
 using Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic;
 using System.Management.Automation.Runspaces;
+using System.Collections;
 
 namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
 {
@@ -36,6 +37,7 @@ public class Helper
         private Object getCommandLock = new object();
         private readonly static Version minSupportedPSVersion = new Version(3, 0);
         private Dictionary<string, Dictionary<string, object>> ruleArguments;
+        private PSVersionTable psVersionTable;
 
         #endregion
 
@@ -1860,6 +1862,26 @@ public static bool IsModuleManifest(string filepath, Version powershellVersion =
             // check if the keys given in module manifest are a proper subset of Keys
             return map.Keys.All(x => allKeys.Concat(deprecatedKeys).Contains(x, StringComparer.OrdinalIgnoreCase));
         }
+
+        public void SetPSVersionTable(Hashtable psVersionTable)
+        {
+            if (psVersionTable == null)
+            {
+                throw new ArgumentNullException("psVersionTable");
+            }
+
+            this.psVersionTable = new PSVersionTable(psVersionTable);
+        }
+
+#if CORECLR
+        public SemanticVersion GetPSVersion()
+#else
+        public Version GetPSVersion()
+#endif
+        {
+            return psVersionTable == null ? null : psVersionTable.PSVersion;
+        }
+
 #endregion Methods
     }
 
@@ -3802,6 +3824,49 @@ private int GetIndex(T vertex)
             int idx;
             return vertexIndexMap.TryGetValue(vertex, out idx) ? idx : -1;
         }
+    }
+
+    internal class PSVersionTable
+    {
+        private readonly string psVersionKey = "PSVersion";
+        private readonly string psEditionKey = "PSEdition";
+#if CORECLR
+        public SemanticVersion PSVersion { get; private set; }
+#else
+        public Version PSVersion { get; private set; }
+#endif
+        public string PSEdition { get; private set; }
 
+        public PSVersionTable(Hashtable psVersionTable)
+        {
+            if (psVersionTable == null)
+            {
+                throw new ArgumentNullException("psVersionTable");
+            }
+
+            if (!psVersionTable.ContainsKey(psVersionKey))
+            {
+                throw new ArgumentException("Input PSVersionTable does not contain PSVersion key"); // TODO localize
+            }
+
+#if CORECLR
+            PSVersion = psVersionTable[psVersionKey] as SemanticVersion;
+#else
+            PSVersion = psVersionTable[psVersionKey] as Version;
+#endif
+            if (PSVersion == null)
+            {
+                throw new ArgumentException("Input PSVersionTable has invalid PSVersion value type"); // TODO localize
+            }
+
+            if (psVersionTable.ContainsKey(psEditionKey))
+            {
+                PSEdition = psVersionTable[psEditionKey] as string;
+                if (PSEdition == null)
+                {
+                    throw new ArgumentException("Input PSVersionTable has invalid PSEdition value type"); // TODO localize
+                }
+            }
+        }
     }
 }

Rules/UsePSCredentialType.cs

@@ -44,40 +44,51 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
             if (ast == null) throw new ArgumentNullException(Strings.NullAstErrorMessage);
 
             var sbAst = ast as ScriptBlockAst;
+
+            var requiresTransformationAttribute = false;
+            var psVersion = Helper.Instance.GetPSVersion();
+            if (psVersion != null && psVersion.Major < 5)
+            {
+                requiresTransformationAttribute = true;
+            }
+
             if (sbAst != null
                     && sbAst.ScriptRequirements != null
                     && sbAst.ScriptRequirements.RequiredPSVersion != null
                     && sbAst.ScriptRequirements.RequiredPSVersion.Major == 5)
             {
-                    yield break;
+                    if (requiresTransformationAttribute)
+                    {
+                        yield break;
+                    }
             }
 
             IEnumerable<Ast> funcDefAsts = ast.FindAll(testAst => testAst is FunctionDefinitionAst, true);
             IEnumerable<Ast> scriptBlockAsts = ast.FindAll(testAst => testAst is ScriptBlockAst, true);
 
-            string funcName;
-            IEnumerable<DiagnosticRecord> diagnosticRecords = Enumerable.Empty<DiagnosticRecord>();
+            List<DiagnosticRecord> diagnosticRecords = new List<DiagnosticRecord>();
 
             foreach (FunctionDefinitionAst funcDefAst in funcDefAsts)
             {
-                funcName = funcDefAst.Name;
-
+                IEnumerable<ParameterAst> parameterAsts = null;
                 if (funcDefAst.Parameters != null)
                 {
-                    diagnosticRecords.Concat(GetViolations(
-                        funcDefAst.Parameters,
-                        funcDefAst,
-                        string.Format(CultureInfo.CurrentCulture, Strings.UsePSCredentialTypeError, funcName),
-                        fileName));
+                    parameterAsts = funcDefAst.Parameters;
                 }
 
-                if (funcDefAst.Body.ParamBlock != null)
+                if (funcDefAst.Body.ParamBlock != null
+                    && funcDefAst.Body.ParamBlock.Parameters != null)
                 {
-                    diagnosticRecords.Concat(GetViolations(
-                        funcDefAst.Body.ParamBlock.Parameters,
-                        funcDefAst,
-                        string.Format(CultureInfo.CurrentCulture, Strings.UsePSCredentialTypeError, funcName),
-                        fileName));
+                    parameterAsts = funcDefAst.Body.ParamBlock.Parameters;
+                }
+
+                if (parameterAsts != null)
+                {
+                    diagnosticRecords.AddRange(GetViolations(
+                        parameterAsts,
+                        string.Format(CultureInfo.CurrentCulture, Strings.UsePSCredentialTypeError, funcDefAst.Name),
+                        fileName,
+                        requiresTransformationAttribute));
                 }
             }
 
@@ -91,11 +102,11 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
 
                 if (scriptBlockAst.ParamBlock != null && scriptBlockAst.ParamBlock.Parameters != null)
                 {
-                    diagnosticRecords.Concat(GetViolations(
+                    diagnosticRecords.AddRange(GetViolations(
                         scriptBlockAst.ParamBlock.Parameters,
-                        scriptBlockAst,
                         string.Format(CultureInfo.CurrentCulture, Strings.UsePSCredentialTypeErrorSB),
-                        fileName));
+                        fileName,
+                        requiresTransformationAttribute));
                 }
             }
 
@@ -107,35 +118,47 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
 
         private IEnumerable<DiagnosticRecord> GetViolations(
             IEnumerable<ParameterAst> parameterAsts,
-            Ast parentAst,
             string errorMessage,
-            string fileName)
+            string fileName,
+            bool requiresTransformationAttribute)
         {
                 foreach (ParameterAst parameter in parameterAsts)
                 {
-                    if (WrongCredentialUsage(parameter))
+                    if (WrongCredentialUsage(parameter, requiresTransformationAttribute))
                     {
                         yield return new DiagnosticRecord(
                             errorMessage,
-                            parentAst.Extent,
+                            parameter.Extent,
                             GetName(),
                             DiagnosticSeverity.Warning,
                             fileName);
                     }
                 }
         }
 
-        private bool WrongCredentialUsage(ParameterAst parameter)
+        private bool WrongCredentialUsage(ParameterAst parameter, bool requiresTransformationAttribute)
         {
             if (parameter.Name.VariablePath.UserPath.Equals("Credential", StringComparison.OrdinalIgnoreCase))
             {
                 var psCredentialType = parameter.Attributes.FirstOrDefault(paramAttribute => (paramAttribute.TypeName.IsArray && (paramAttribute.TypeName as ArrayTypeName).ElementType.GetReflectionType() == typeof(PSCredential))
                     || paramAttribute.TypeName.GetReflectionType() == typeof(PSCredential));
 
+                if (psCredentialType == null)
+                {
+                    return true;
+                }
+
+                if (!requiresTransformationAttribute && psCredentialType != null)
+                {
+                    return false;
+                }
+
                 var credentialAttribute = parameter.Attributes.FirstOrDefault(paramAttribute => paramAttribute.TypeName.GetReflectionType() == typeof(CredentialAttribute));
 
                 // check that both exists and pscredentialtype comes before credential attribute
-                if (psCredentialType != null && credentialAttribute != null && psCredentialType.Extent.EndOffset <= credentialAttribute.Extent.StartOffset)
+                if (psCredentialType != null
+                        && credentialAttribute != null
+                        && psCredentialType.Extent.EndOffset <= credentialAttribute.Extent.StartOffset)
                 {
                     return false;
                 }