New PowerShell compatibility rules

.gitignore

@@ -25,6 +25,9 @@ bld/
 # Visual Studo 2015 cache/options directory
 .vs/
 
+# VSCode configuration directory
+.vscode/
+
 # MSTest test Results
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
@@ -212,3 +215,6 @@ PSScriptAnalyzer/
 
 # Test result file
 TestResults.xml
+
+# PSCompatibilityAnalyzer module
+PSCompatibilityAnalyzer/out/

.vscode/settings.json

@@ -4,5 +4,10 @@
     "powershell.codeFormatting.preset": "Allman",
     "[powershell]": {
         "files.trimTrailingWhitespace": true
+    },
+    "search.exclude": {
+        "**/node_modules": true,
+        "**/bower_components": true,
+        "/CrossCompatibility/profiles": true
     }
 }

Engine/Engine.csproj

@@ -76,7 +76,7 @@
   <ItemGroup Condition="'$(TargetFramework)' == 'net452' AND '$(Configuration)' != 'PSV3Release'">
     <PackageReference Include="Microsoft.PowerShell.5.ReferenceAssemblies" Version="1.1.0" />
   </ItemGroup>
-
+   
   <PropertyGroup Condition=" '$(Configuration)' == 'PSV3Release' ">
     <DefineConstants>$(DefineConstants);PSV3</DefineConstants>
   </PropertyGroup>
@@ -85,4 +85,12 @@
     <DefineConstants>$(DefineConstants);PSV3;PSV4</DefineConstants>
   </PropertyGroup>
 
+  <PropertyGroup Condition=" '$(Configuration)' == 'PSV3Debug' ">
+    <DefineConstants>$(DefineConstants);PSV3</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)' == 'PSV4Debug' ">
+    <DefineConstants>$(DefineConstants);PSV3;PSV4</DefineConstants>
+  </PropertyGroup>
+
 </Project>

Engine/Generic/ConfigurableRule.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Management.Automation;
 using System.Management.Automation.Language;
 using System.Reflection;
 
@@ -118,6 +119,13 @@ private void SetDefaultValues()
 
         private void SetValue(PropertyInfo property, object value)
         {
+            if (IsArray(property.PropertyType, out Type elementType))
+            {
+                object newArray = LanguagePrimitives.ConvertTo(value, elementType.MakeArrayType());
+                property.SetValue(this, newArray);
+                return;
+            }
+
             // TODO Check if type is convertible
             property.SetValue(this, Convert.ChangeType(value, property.PropertyType));
         }
@@ -145,5 +153,17 @@ private Object GetDefaultValue(PropertyInfo property)
 
             return ((ConfigurableRulePropertyAttribute)attr).DefaultValue;
         }
+
+        private static bool IsArray(Type propertyType, out Type elementType)
+        {
+            if (propertyType.IsArray)
+            {
+                elementType = propertyType.GetElementType();
+                return true;
+            }
+
+            elementType = null;
+            return false;
+        }
     }
 }

Engine/Generic/ConfigurableRulePropertyAttribute.cs

@@ -11,6 +11,12 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic
     [AttributeUsage(AttributeTargets.Property)]
     public class ConfigurableRulePropertyAttribute : Attribute
     {
+        // TODO: Remove this parameter or make it optional.
+        //       Properties already have a way to specify default values in C#.
+        //       Having this prevents using null (which may be legitimate)
+        //       or values from other assemblies, and overrides the constructor,
+        //       which just makes life harder.
+
         /// <summary>
         /// Default value of the property that the attribute decorates.
         /// </summary>
@@ -22,6 +28,7 @@ public class ConfigurableRulePropertyAttribute : Attribute
         /// <param name="defaultValue"></param>
         public ConfigurableRulePropertyAttribute(object defaultValue)
         {
+            // TODO: null is a legitimate value and should be allowed.
             if (defaultValue == null)
             {
                 throw new ArgumentNullException(nameof(defaultValue), Strings.ConfigurableScriptRuleNRE);

Engine/PSScriptAnalyzer.psm1

@@ -17,13 +17,10 @@ if (($PSVersionTable.Keys -contains "PSEdition") -and ($PSVersionTable.PSEdition
         throw "Minimum supported version of PSScriptAnalyzer for PowerShell Core is 6.0.2 but current version is '$($PSVersionTable.PSVersion)'. Please update PowerShell Core."
     }
 }
-else {
-    if ($PSVersionTable.PSVersion.Major -eq 3) {
-        $binaryModuleRoot = Join-Path -Path $PSModuleRoot -ChildPath 'PSv3'
-    }
-    elseif ($PSVersionTable.PSVersion.Major -eq 4) {
-        $binaryModuleRoot = Join-Path -Path $PSModuleRoot -ChildPath 'PSv4'
-    }
+elseif ($PSVersionTable.PSVersion.Major -le 4) {
+    $binaryModuleRoot = Join-Path -Path $PSModuleRoot -ChildPath "PSv$($PSVersionTable.PSVersion.Major)"
+    # Without this, PSSA tries to load this from $PSHome
+    Add-Type -Path "$binaryModuleRoot/Newtonsoft.Json.dll"
 }
 
 $binaryModulePath = Join-Path -Path $binaryModuleRoot -ChildPath 'Microsoft.Windows.PowerShell.ScriptAnalyzer.dll'

Engine/ScriptAnalyzer.cs

@@ -876,39 +876,37 @@ private IEnumerable<T> GetInterfaceImplementationsFromAssembly<T>() where T : cl
 
         private IEnumerable<T> GetInterfaceImplementationsFromAssembly<T>(string ruleDllPath) where T : class
         {
-            var fileName = Path.GetFileNameWithoutExtension(ruleDllPath);
+            string fileName = Path.GetFileNameWithoutExtension(ruleDllPath);
             var assemblyName = new AssemblyName(fileName);
             outputWriter.WriteVerbose(string.Format("Loading Assembly:{0}", assemblyName.FullName));
 
-            var dll = Assembly.Load(assemblyName);
-            var rules = new List<T>();
+            Assembly dll = Assembly.Load(assemblyName);
+
             if (dll == null)
             {
                 outputWriter.WriteVerbose(string.Format("Cannot load {0}", ruleDllPath));
-                return rules;
+                return Enumerable.Empty<T>();
             }
-            foreach (var type in dll.ExportedTypes)
+
+            var rules = new List<T>();
+            foreach (Type type in dll.ExportedTypes)
             {
-                var typeInfo = type.GetTypeInfo();
-                if (!typeInfo.IsInterface
-                    && !typeInfo.IsAbstract
-                    && typeInfo.ImplementedInterfaces.Contains(typeof(T)))
+                if (type.IsInterface
+                    || type.IsAbstract
+                    || !typeof(T).IsAssignableFrom(type))
+                {
+                    continue;
+                }
+
+                var rule = Activator.CreateInstance(type) as T;
+                if (rule == null)
                 {
                     outputWriter.WriteVerbose(
                         string.Format(
-                            "Creating Instance of {0}", type.Name));
-
-                    var ruleObj = Activator.CreateInstance(type);
-                    T rule = ruleObj as T;
-                    if (rule == null)
-                    {
-                        outputWriter.WriteVerbose(
-                            string.Format(
-                                "Cannot cast instance of type {0} to {1}", type.Name, typeof(T).GetTypeInfo().Name));
-                        continue;
-                    }
-                    rules.Add(rule);
+                            "Cannot cast instance of type {0} to {1}", type.Name, typeof(T).GetTypeInfo().Name));
+                    continue;
                 }
+                rules.Add(rule);
             }
             return rules;
         }