Address @JamesWTruher's feedback

Author: rjmholt

PSCompatibilityCollector/Microsoft.PowerShell.CrossCompatibility/Collection/CompatibilityProfileCollector.cs

@@ -42,23 +42,27 @@ public Builder()
             }
 
             /// <summary>
-            /// Add path prefixes of modules to exclude.
+            /// Modules on paths starting with these prefixes will excluded from profile collection.
             /// </summary>
-            /// <param name="modulePrefixes">Path prefixes of modules to exclude.</param>
-            public Builder ExcludedModulePathPrefixes(IReadOnlyCollection<string> modulePrefixes)
+            public IReadOnlyCollection<string> ExcludedModulePathPrefixes
             {
-                _pwshDataCollectorBuilder.ExcludedModulePathPrefixes(modulePrefixes);
-                return this;
+                get => _pwshDataCollectorBuilder.ExcludedModulePathPrefixes;
+                set
+                {
+                    _pwshDataCollectorBuilder.ExcludedModulePathPrefixes = value;
+                }
             }
 
             /// <summary>
-            /// Add path prefixes of assemblies to exclude.
+            /// .NET assemblies on paths starting with these prefixes will excluded from profile collection.
             /// </summary>
-            /// <param name="assemblyPrefixes">Path prefixes of assemblies to exclude.</param>
-            public Builder ExcludeAssemblyPathPrefixes(IReadOnlyCollection<string> assemblyPrefixes)
+            public IReadOnlyCollection<string> ExcludedAssemblyPathPrefixes
             {
-                _typeDataColletorBuilder.ExcludedAssemblyPathPrefixes(assemblyPrefixes);
-                return this;
+                get => _typeDataColletorBuilder.ExcludedAssemblyPathPrefixes;
+                set
+                {
+                    _typeDataColletorBuilder.ExcludedAssemblyPathPrefixes = value;
+                }
             }
 
             /// <summary>
@@ -269,9 +273,9 @@ protected virtual void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    _pwsh.Dispose();
-                    _platformInfoCollector.Dispose();
                     _pwshDataCollector.Dispose();
+                    _platformInfoCollector.Dispose();
+                    _pwsh.Dispose();
                 }
 
                 _pwsh = null;

PSCompatibilityCollector/Microsoft.PowerShell.CrossCompatibility/Collection/PlatformInformationCollector.cs

@@ -143,7 +143,7 @@ public OperatingSystemData GetOperatingSystemData()
                     {
                         osData.ServicePack = Environment.OSVersion.ServicePack;
                     }
-                    osData.SkuId = GetSkuId();
+                    osData.SkuId = GetWinSkuId();
                     break;
 
                 case OSFamily.Linux:
@@ -265,8 +265,11 @@ private DotnetRuntime GetDotnetRuntime()
         /// Get the Windows SKU ID of the current PowerShell session.
         /// </summary>
         /// <returns>An unsigned 32-bit integer representing the SKU of the current Windows OS.</returns>
-        private uint GetSkuId()
+        private uint GetWinSkuId()
         {
+            // There are a few ways to get this, with varying support on different systems.
+            // So we try them in order from least to most expensive.
+
             // If we have a cached value here, try this first
             if (_lazyWin32OperatingSystemInfo.IsValueCreated
                 && _lazyWin32OperatingSystemInfo.Value != null

PSCompatibilityCollector/Microsoft.PowerShell.CrossCompatibility/Collection/PowerShellDataCollector.cs

@@ -27,17 +27,10 @@ public class PowerShellDataCollector : IDisposable
         /// </summary>
         public class Builder
         {
-            private IReadOnlyCollection<string> _modulePrefixes;
-
             /// <summary>
-            /// Add path prefixes that modules should be excluded with.
+            /// Modules on paths underneath any of these will be excluded.
             /// </summary>
-            /// <param name="modulePrefixes">The path prefixes of modules to exclude.</param>
-            public Builder ExcludedModulePathPrefixes(IReadOnlyCollection<string> modulePrefixes)
-            {
-                _modulePrefixes = modulePrefixes;
-                return this;
-            }
+            public IReadOnlyCollection<string> ExcludedModulePathPrefixes { get; set; }
 
             /// <summary>
             /// Build a new PowerShellDataCollector with the given configuration.
@@ -47,7 +40,7 @@ public Builder ExcludedModulePathPrefixes(IReadOnlyCollection<string> modulePref
             /// <returns>The constructed PowerShell data collector object.</returns>
             public PowerShellDataCollector Build(SMA.PowerShell pwsh, PowerShellVersion psVersion)
             {
-                return new PowerShellDataCollector(pwsh, psVersion, _modulePrefixes);
+                return new PowerShellDataCollector(pwsh, psVersion, ExcludedModulePathPrefixes);
             }
         }
 
@@ -57,7 +50,7 @@ public PowerShellDataCollector Build(SMA.PowerShell pwsh, PowerShellVersion psVe
 
         private const string THIS_MODULE_NAME = "PSCompatibilityCollector";
 
-        private static readonly Regex s_typeDataRegex = new Regex("Error in TypeData \"([A-Za-z.]+)\"", RegexOptions.Compiled);
+        private static readonly Regex s_typeDataRegex = new Regex("Error in TypeData \"([A-Za-z\\.]+)\"", RegexOptions.Compiled);
 
         private static readonly CmdletInfo s_gmoInfo = new CmdletInfo("Get-Module", typeof(GetModuleCommand));
 
@@ -151,7 +144,7 @@ public IEnumerable<Tuple<string, Version, ModuleData>> GetModulesData(out IEnume
 
                 Tuple<string, Version, ModuleData> moduleData = LoadAndGetModuleData(module, out Exception error);
 
-                if (moduleData == null)
+                if (moduleData == null && error != null)
                 {
                     errs.Add(error);
                     continue;
@@ -306,26 +299,30 @@ public Tuple<string, Version, ModuleData> GetCoreModuleData()
             // Get default variables and core aliases out of a fresh runspace
             using (SMA.PowerShell freshPwsh = SMA.PowerShell.Create(RunspaceMode.NewRunspace))
             {
-                Collection<PSVariable> defaultVariables = freshPwsh.AddCommand("Get-ChildItem")
-                    .AddParameter("Path", "variable:")
-                    .InvokeAndClear<PSVariable>();
+                Collection<PSObject> varsAndAliases = freshPwsh.AddCommand("Get-ChildItem")
+                    .AddParameter("Path", "variable:,alias:")
+                    .InvokeAndClear();
+
+                var variables = new List<string>();
+                var aliases = new JsonCaseInsensitiveStringDictionary<string>();
 
-                var variableArray = new string[defaultVariables.Count];
-                for (int i = 0; i < variableArray.Length; i++)
+                foreach (PSObject returnedObject in varsAndAliases)
                 {
-                    variableArray[i] = defaultVariables[i].Name;
-                }
-                moduleData.Variables = variableArray;
+                    switch (returnedObject.BaseObject)
+                    {
+                        case PSVariable variable:
+                            variables.Add(variable.Name);
+                            continue;
 
-                IEnumerable<AliasInfo> coreAliases = freshPwsh.AddCommand("Get-ChildItem")
-                    .AddParameter("Path", "alias:")
-                    .InvokeAndClear<AliasInfo>();
+                        case AliasInfo alias:
+                            aliases.Add(alias.Name, GetSingleAliasData(alias));
+                            continue;
 
-                var aliases = new JsonCaseInsensitiveStringDictionary<string>();
-                foreach (AliasInfo aliasInfo in coreAliases)
-                {
-                    aliases.Add(aliasInfo.Name, GetSingleAliasData(aliasInfo));
+                        // Skip over other objects we get back, since there's no reason to throw
+                    }
                 }
+
+                moduleData.Variables = variables.ToArray();
                 moduleData.Aliases = aliases;
             }
 
@@ -676,8 +673,9 @@ private bool IsExcludedPath(string path)
 
         private static ReadOnlySet<string> GetPowerShellCommonParameterNames()
         {
+            const BindingFlags propertyBindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
             var set = new List<string>();
-            foreach (PropertyInfo property in typeof(CommonParameters).GetProperties())
+            foreach (PropertyInfo property in typeof(CommonParameters).GetProperties(propertyBindingFlags))
             {
                 set.Add(property.Name);
             }

PSCompatibilityCollector/Microsoft.PowerShell.CrossCompatibility/Collection/TypeDataCollector.cs

@@ -27,26 +27,19 @@ public class TypeDataCollector
         /// </summary>
         public class Builder
         {
-            private IReadOnlyCollection<string> _excludedAssemblyPathPrefixes;
-
             /// <summary>
-            /// Exclude assemblies on paths starting with the given prefixes when collecting
-            /// .NET type information.
+            /// Assemblies on paths starting with these prefixes will be excluded
+            /// when collecting .NET type information.
             /// </summary>
-            /// <param name="assemblyPrefixes">The path prefixes to exclude assemblies with.</param>
-            public Builder ExcludedAssemblyPathPrefixes(IReadOnlyCollection<string> assemblyPrefixes)
-            {
-                _excludedAssemblyPathPrefixes = assemblyPrefixes;
-                return this;
-            }
+            public IReadOnlyCollection<string> ExcludedAssemblyPathPrefixes { get; set; }
 
             /// <summary>
             /// Build the configured TypeDataCollector object.
             /// </summary>
             /// <returns>The constructed TypeDataCollector object.</returns>
             public TypeDataCollector Build()
             {
-                return new TypeDataCollector(_excludedAssemblyPathPrefixes);
+                return new TypeDataCollector(ExcludedAssemblyPathPrefixes);
             }
         }
 
@@ -190,7 +183,7 @@ public KeyValuePair<string, AssemblyData> AssembleAssembly(Assembly asm)
             if (types.Length > 0)
             {
                 namespacedTypes = new JsonDictionary<string, JsonDictionary<string, TypeData>>();
-                foreach (Type type in asm.GetTypes())
+                foreach (Type type in types)
                 {
                     if (!type.IsPublic)
                     {

PSCompatibilityCollector/Microsoft.PowerShell.CrossCompatibility/Commands/NewPSCompatibilityProfileCommand.cs

@@ -96,12 +96,12 @@ protected override void EndProcessing()
 
                 if (ExcludeModulePathPrefix != null && ExcludeModulePathPrefix.Length > 0)
                 {
-                    collectorBuilder.ExcludedModulePathPrefixes(ExcludeModulePathPrefix);
+                    collectorBuilder.ExcludedModulePathPrefixes = ExcludeModulePathPrefix;
                 }
 
                 if (ExcludeAssemblyPathPrefix != null && ExcludeAssemblyPathPrefix.Length > 0)
                 {
-                    collectorBuilder.ExcludeAssemblyPathPrefixes(ExcludeAssemblyPathPrefix);
+                    collectorBuilder.ExcludedAssemblyPathPrefixes = ExcludeAssemblyPathPrefix;
                 }
 
                 using (var profileCollector = collectorBuilder.Build(pwsh))