PowerShell · daxian-dbw · Jul 16, 2018 · Jun 22, 2018 · Jul 3, 2018 · Jul 3, 2018
@@ -1196,11 +1196,24 @@ private static IEnumerable<FormatViewDefinition> ViewsOf_ModuleInfoGrouping(Cust
                     .AddHeader(Alignment.Left, width: 10)
                     .AddHeader(Alignment.Left, width: 10)
                     .AddHeader(Alignment.Left, width: 35)
+                    .AddHeader(Alignment.Left, width: 9, label: "PSEdition")
                     .AddHeader(Alignment.Left, label: "ExportedCommands")
                     .StartRowDefinition()
                         .AddPropertyColumn("ModuleType")
                         .AddPropertyColumn("Version")
                         .AddPropertyColumn("Name")
+                        .AddScriptBlockColumn(@"
+                            $result = [System.Collections.ArrayList]::new()
+                            $editions = $_.CompatiblePSEditions
+                            if (-not $editions)
+                            {
+                                $editions = @('Desktop')
+                            }
+                            foreach ($edition in $editions)
+                            {
+                                $result += $edition.Substring(0,4)
+                            }
+                            ($result | Sort-Object) -join ','")
                         .AddScriptBlockColumn("$_.ExportedCommands.Keys")
                     .EndRowDefinition()
                 .EndTable());

@@ -398,7 +398,7 @@ public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst fun
 
         #region Module Names
 
-        internal static List<CompletionResult> CompleteModuleName(CompletionContext context, bool loadedModulesOnly)
+        internal static List<CompletionResult> CompleteModuleName(CompletionContext context, bool loadedModulesOnly, bool skipEditionCheck = false)
         {
             var moduleName = context.WordToComplete ?? string.Empty;
             var result = new List<CompletionResult>();
@@ -413,6 +413,12 @@ internal static List<CompletionResult> CompleteModuleName(CompletionContext cont
             if (!loadedModulesOnly)
             {
                 powershell.AddParameter("ListAvailable", true);
+
+                // -SkipEditionCheck should only be set or apply to -ListAvailable
+                if (skipEditionCheck)
+                {
+                    powershell.AddParameter("SkipEditionCheck", true);
+                }
             }
 
             Exception exceptionThrown;
@@ -2101,17 +2107,19 @@ private static void NativeCommandArgumentCompletion(
                 case "Get-Module":
                     {
                         bool loadedModulesOnly = boundArguments == null || !boundArguments.ContainsKey("ListAvailable");
-                        NativeCompletionModuleCommands(context, parameterName, loadedModulesOnly, /* isImportModule: */ false, result);
+                        bool skipEditionCheck = !loadedModulesOnly && boundArguments.ContainsKey("SkipEditionCheck");
+                        NativeCompletionModuleCommands(context, parameterName, result, loadedModulesOnly, skipEditionCheck: skipEditionCheck);
                         break;
                     }
                 case "Remove-Module":
                     {
-                        NativeCompletionModuleCommands(context, parameterName, /* loadedModulesOnly: */ true, /* isImportModule: */ false, result);
+                        NativeCompletionModuleCommands(context, parameterName, result, loadedModulesOnly: true);
                         break;
                     }
                 case "Import-Module":
                     {
-                        NativeCompletionModuleCommands(context, parameterName, /* loadedModulesOnly: */ false, /* isImportModule: */ true, result);
+                        bool skipEditionCheck = boundArguments != null && boundArguments.ContainsKey("SkipEditionCheck");
+                        NativeCompletionModuleCommands(context, parameterName, result, isImportModule: true, skipEditionCheck: skipEditionCheck);
                         break;
                     }
                 case "Debug-Process":
@@ -3046,7 +3054,13 @@ private static void NativeCompletionScheduledJobCommands(CompletionContext conte
             }
         }
 
-        private static void NativeCompletionModuleCommands(CompletionContext context, string paramName, bool loadedModulesOnly, bool isImportModule, List<CompletionResult> result)
+        private static void NativeCompletionModuleCommands(
+            CompletionContext context,
+            string paramName,
+            List<CompletionResult> result,
+            bool loadedModulesOnly = false,
+            bool isImportModule = false,
+            bool skipEditionCheck = false)
         {
             if (string.IsNullOrEmpty(paramName))
             {
@@ -3067,7 +3081,7 @@ private static void NativeCompletionModuleCommands(CompletionContext context, st
                                 StringLiterals.PowerShellILAssemblyExtension,
                                 StringLiterals.PowerShellCmdletizationFileExtension
                             };
-                    var moduleFilesResults = new List<CompletionResult>(CompleteFilename(context, /* containerOnly: */ false, moduleExtensions));
+                    var moduleFilesResults = new List<CompletionResult>(CompleteFilename(context, containerOnly: false, moduleExtensions));
                     if (moduleFilesResults.Count > 0)
                         result.AddRange(moduleFilesResults);
 
@@ -3079,7 +3093,7 @@ private static void NativeCompletionModuleCommands(CompletionContext context, st
                     }
                 }
 
-                var moduleResults = CompleteModuleName(context, loadedModulesOnly);
+                var moduleResults = CompleteModuleName(context, loadedModulesOnly, skipEditionCheck);
                 if (moduleResults != null && moduleResults.Count > 0)
                     result.AddRange(moduleResults);
 

@@ -102,6 +102,12 @@ private static ConcurrentDictionary<string, CommandTypes> AnalyzeManifestModule(
                 var moduleManifestProperties = PsUtils.GetModuleManifestProperties(modulePath, PsUtils.FastModuleManifestAnalysisPropertyNames);
                 if (moduleManifestProperties != null)
                 {
+                    if (ModuleIsEditionIncompatible(modulePath, moduleManifestProperties))
+                    {
+                        ModuleIntrinsics.Tracer.WriteLine($"Module lies on the Windows System32 legacy module path and is incompatible with current PowerShell edition, skipping module: {modulePath}");
+                        return null;
+                    }
+
                     Version version;
                     if (ModuleUtils.IsModuleInVersionSubdirectory(modulePath, out version))
                     {
@@ -160,6 +166,31 @@ private static ConcurrentDictionary<string, CommandTypes> AnalyzeManifestModule(
             return result ?? AnalyzeTheOldWay(modulePath, context, lastWriteTime);
         }
 
+        /// <summary>
+        /// Check if a module is compatible with the current PSEdition given its path and its manifest properties.
+        /// </summary>
+        /// <param name="modulePath">The path to the module.</param>
+        /// <param name="moduleManifestProperties">The properties of the module's manifest.</param>
+        /// <returns></returns>
+        internal static bool ModuleIsEditionIncompatible(string modulePath, Hashtable moduleManifestProperties)
+        {
+#if UNIX
+            return false;
+#else
+            if (!ModuleUtils.IsOnSystem32ModulePath(modulePath))
+            {
+                return false;
+            }
+
+            if (!moduleManifestProperties.ContainsKey("CompatiblePSEditions"))
+            {
+                return true;
+            }
+
+            return !Utils.IsPSEditionSupported(LanguagePrimitives.ConvertTo<string[]>(moduleManifestProperties["CompatiblePSEditions"]));
+#endif
+        }
+
         internal static bool ModuleAnalysisViaGetModuleRequired(object modulePathObj, bool hadCmdlets, bool hadFunctions, bool hadAliases)
         {
             var modulePath = modulePathObj as string;
@@ -449,6 +480,14 @@ internal static void CacheModuleExports(PSModuleInfo module, ExecutionContext co
         {
             ModuleIntrinsics.Tracer.WriteLine("Requested caching for {0}", module.Name);
 
+            // Don't cache incompatible modules on the system32 module path even if loaded with
+            // -SkipEditionCheck, since it will break subsequent sessions.
+            if (!module.IsConsideredEditionCompatible)
+            {
+                ModuleIntrinsics.Tracer.WriteLine($"Module '{module.Name}' not edition compatible and not cached.");
+                return;
+            }
+
             DateTime lastWriteTime;
             ModuleCacheEntry moduleCacheEntry;
             GetModuleEntryFromCache(module.Path, out lastWriteTime, out moduleCacheEntry);

@@ -84,6 +84,18 @@ public sealed class GetModuleCommand : ModuleCmdletBase, IDisposable
         [ArgumentCompleter(typeof(PSEditionArgumentCompleter))]
         public string PSEdition { get; set; }
 
+        /// <summary>
+        /// When set, CompatiblePSEditions checking is disabled for modules in the System32 (Windows PowerShell) module directory.
+        /// </summary>
+        [Parameter(ParameterSetName = ParameterSet_AvailableLocally)]
+        [Parameter(ParameterSetName = ParameterSet_AvailableInPsrpSession)]
+        [Parameter(ParameterSetName = ParameterSet_AvailableInCimSession)]
+        public SwitchParameter SkipEditionCheck
+        {
+            get { return (SwitchParameter)BaseSkipEditionCheck; }
+            set { BaseSkipEditionCheck = value; }
+        }
+
         /// <summary>
         /// If specified, then Get-Module refreshes the internal cmdlet analysis cache
         /// </summary>
@@ -341,6 +353,18 @@ protected override void ProcessRecord()
                 ThrowTerminatingError(error);
             }
 
+            // -SkipEditionCheck only makes sense for -ListAvailable (otherwise the module is already loaded)
+            if (SkipEditionCheck && !ListAvailable)
+            {
+                ErrorRecord error = new ErrorRecord(
+                    new InvalidOperationException(Modules.SkipEditionCheckNotSupportedWithoutListAvailable),
+                    nameof(Modules.SkipEditionCheckNotSupportedWithoutListAvailable),
+                    ErrorCategory.InvalidOperation,
+                    targetObject: null);
+
+                ThrowTerminatingError(error);
+            }
+
             var strNames = new List<string>();
             if (Name != null)
             {
@@ -423,27 +447,12 @@ private void AssertNameDoesNotResolveToAPath(string[] names, string stringFormat
             }
         }
 
-        /// <summary>
-        /// Determine whether a module info matches a given module specification table and specified PSEdition value.
-        /// </summary>
-        /// <param name="moduleInfo"></param>
-        /// <param name="moduleSpecTable"></param>
-        /// <param name="edition"></param>
-        /// <returns></returns>
-        private static bool ModuleMatch(PSModuleInfo moduleInfo, IDictionary<string, ModuleSpecification> moduleSpecTable, string edition)
-        {
-            ModuleSpecification moduleSpecification;
-            return (String.IsNullOrEmpty(edition) || moduleInfo.CompatiblePSEditions.Contains(edition, StringComparer.OrdinalIgnoreCase)) &&
-                   (!moduleSpecTable.TryGetValue(moduleInfo.Name, out moduleSpecification) || ModuleIntrinsics.IsModuleMatchingModuleSpec(moduleInfo, moduleSpecification));
-        }
-
         private void GetAvailableViaCimSession(IEnumerable<string> names, IDictionary<string, ModuleSpecification> moduleSpecTable,
                                                CimSession cimSession, Uri resourceUri, string cimNamespace)
         {
-            var remoteModules = GetAvailableViaCimSessionCore(names, cimSession, resourceUri, cimNamespace);
+            IEnumerable<PSModuleInfo> remoteModules = GetAvailableViaCimSessionCore(names, cimSession, resourceUri, cimNamespace);
 
-            foreach (var remoteModule in remoteModules.Where(remoteModule => ModuleMatch(remoteModule, moduleSpecTable, PSEdition))
-                )
+            foreach (PSModuleInfo remoteModule in FilterModulesForEditionAndSpecification(remoteModules, moduleSpecTable))
             {
                 RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, cimSession, resourceUri,
                                                                        cimNamespace);
@@ -453,10 +462,9 @@ private void GetAvailableViaCimSession(IEnumerable<string> names, IDictionary<st
 
         private void GetAvailableViaPsrpSession(string[] names, IDictionary<string, ModuleSpecification> moduleSpecTable, PSSession session)
         {
-            var remoteModules = GetAvailableViaPsrpSessionCore(names, session.Runspace);
+            IEnumerable<PSModuleInfo> remoteModules = GetAvailableViaPsrpSessionCore(names, session.Runspace);
 
-            foreach (var remoteModule in remoteModules.Where(remoteModule => ModuleMatch(remoteModule, moduleSpecTable, PSEdition))
-                )
+            foreach (PSModuleInfo remoteModule in FilterModulesForEditionAndSpecification(remoteModules, moduleSpecTable))
             {
                 RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, session);
                 this.WriteObject(remoteModule);
@@ -465,14 +473,10 @@ private void GetAvailableViaPsrpSession(string[] names, IDictionary<string, Modu
 
         private void GetAvailableLocallyModules(string[] names, IDictionary<string, ModuleSpecification> moduleSpecTable, bool all)
         {
-            var refresh = Refresh.IsPresent;
-            var modules = GetModule(names, all, refresh);
-
-            foreach (
-                var psModule in
-                    modules.Where(module => ModuleMatch(module, moduleSpecTable, PSEdition)).Select(module => new PSObject(module))
-                )
+            IEnumerable<PSModuleInfo> modules = GetModule(names, all, Refresh);
+            foreach (PSModuleInfo module in FilterModulesForEditionAndSpecification(modules, moduleSpecTable))
             {
+                var psModule = new PSObject(module);
                 psModule.TypeNames.Insert(0, "ModuleInfoGrouping");
                 WriteObject(psModule);
             }
@@ -482,14 +486,74 @@ private void GetLoadedModules(string[] names, IDictionary<string, ModuleSpecific
         {
             var modulesToWrite = Context.Modules.GetModules(names, all);
 
-            foreach (
-                var moduleInfo in
-                    modulesToWrite.Where(moduleInfo => ModuleMatch(moduleInfo, moduleSpecTable, PSEdition))
-                )
+            foreach (PSModuleInfo moduleInfo in FilterModulesForEditionAndSpecification(modulesToWrite, moduleSpecTable))
             {
                 WriteObject(moduleInfo);
             }
         }
+
+        /// <summary>
+        /// Filter an enumeration of PowerShell modules based on the required PowerShell edition
+        /// and the module specification constraints set for each module (if any).
+        /// </summary>
+        /// <param name="modules">The modules to filter through.</param>
+        /// <param name="moduleSpecificationTable">Module constraints, keyed by module name, to filter modules of that name by.</param>
+        /// <returns>All modules from the original input that meet both any module edition and module specification constraints provided.</returns>
+        private IEnumerable<PSModuleInfo> FilterModulesForEditionAndSpecification(
+            IEnumerable<PSModuleInfo> modules,
+            IDictionary<string, ModuleSpecification> moduleSpecificationTable)
+        {
+#if !UNIX
+            // Edition check only applies to Windows System32 module path
+            if (!SkipEditionCheck && ListAvailable && !All)
+            {
+                modules = modules.Where(module => module.IsConsideredEditionCompatible);
+            }
+#endif
+
+            if (!String.IsNullOrEmpty(PSEdition))
+            {
+                modules = modules.Where(module => module.CompatiblePSEditions.Contains(PSEdition, StringComparer.OrdinalIgnoreCase));
+            }
+
+            if (moduleSpecificationTable != null && moduleSpecificationTable.Count > 0)
+            {
+                modules = FilterModulesForSpecificationMatch(modules, moduleSpecificationTable);
+            }
+
+            return modules;
+        }
+
+        /// <summary>
+        /// Take an enumeration of modules and only return those that match a specification
+        /// in the given specification table, or have no corresponding entry in the specification table.
+        /// </summary>
+        /// <param name="modules">The modules to filter by specification match.</param>
+        /// <param name="moduleSpecificationTable">The specification lookup table to filter the modules on.</param>
+        /// <returns>The modules that match their corresponding table entry, or which have no table entry.</returns>
+        private static IEnumerable<PSModuleInfo> FilterModulesForSpecificationMatch(
+            IEnumerable<PSModuleInfo> modules,
+            IDictionary<string, ModuleSpecification> moduleSpecificationTable)
+        {
+            Dbg.Assert(moduleSpecificationTable != null, $"Caller to verify that {nameof(moduleSpecificationTable)} is not null");
+            Dbg.Assert(moduleSpecificationTable.Count != 0, $"Caller to verify that {nameof(moduleSpecificationTable)} is not empty");
+
+            foreach (PSModuleInfo module in modules)
+            {
+                // No table entry means we return the module
+                if (!moduleSpecificationTable.TryGetValue(module.Name, out ModuleSpecification moduleSpecification))
+                {
+                    yield return module;
+                    continue;
+                }
+
+                // Modules with table entries only get returned if they match them
+                if (ModuleIntrinsics.IsModuleMatchingModuleSpec(module, moduleSpecification))
+                {
+                    yield return module;
+                }
+            }
+        }
     }
 
     /// <summary>
@@ -513,5 +577,4 @@ public IEnumerable<CompletionResult> CompleteArgument(string commandName, string
             }
         }
     }
-} // Microsoft.PowerShell.Commands
-
+}
@@ -207,6 +207,16 @@ public SwitchParameter Force
             set { BaseForce = value; }
         }
 
+        /// <summary>
+        /// Skips the check on CompatiblePSEditions for modules loaded from the System32 module path.
+        /// </summary>
+        [Parameter]
+        public SwitchParameter SkipEditionCheck
+        {
+            get { return (SwitchParameter)BaseSkipEditionCheck; }
+            set { BaseSkipEditionCheck = value; }
+        }
+
         /// <summary>
         /// This parameter causes the session state instance to be written...
         /// </summary>