Add preliminary New-PSCompatibilityProfile cmdlet implementation

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

@@ -5,6 +5,7 @@
 using System.Management.Automation;
 using System.Management.Automation.Internal;
 using System.Reflection;
+using System.Text.RegularExpressions;
 using Microsoft.PowerShell.Commands;
 using Microsoft.PowerShell.CrossCompatibility.Data.Modules;
 using Microsoft.PowerShell.CrossCompatibility.Utility;
@@ -18,6 +19,8 @@ public class PowerShellDataCollector : IDisposable
 
         private const string CORE_MODULE_NAME = "Microsoft.PowerShell.Core";
 
+        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));
 
         private static readonly CmdletInfo s_ipmoInfo = new CmdletInfo("Import-Module", typeof(ImportModuleCommand));
@@ -77,47 +80,78 @@ public IEnumerable<Tuple<string, Version, ModuleData>> GetModulesData(out IEnume
             var errs = new List<Exception>();
             foreach (PSModuleInfo module in modules)
             {
-                try
+                Tuple<string, Version, ModuleData> moduleData = LoadAndGetModuleData(module, out Exception error);
+
+                if (moduleData == null)
                 {
-                    PSModuleInfo importedModule = _pwsh.AddCommand(s_ipmoInfo)
-                        .AddParameter("ModuleInfo", module)
-                        .AddParameter("PassThru")
-                        .AddParameter("ErrorAction", "Stop")
-                        .InvokeAndClear<PSModuleInfo>()
-                        .FirstOrDefault();
-
-                    moduleDatas.Add(GetSingleModuleData(importedModule));
-
-                    _pwsh.AddCommand(s_rmoInfo)
-                        .AddParameter("ModuleInfo", importedModule)
-                        .InvokeAndClear();
+                    errs.Add(error);
+                    continue;
                 }
-                catch (CmdletInvocationException)
+
+                moduleDatas.Add(moduleData);
+            }
+
+            errors = errs;
+            return moduleDatas;
+        }
+
+        public Tuple<string, Version, ModuleData> LoadAndGetModuleData(PSModuleInfo module, out Exception error)
+        {
+            try
+            {
+                PSModuleInfo importedModule = _pwsh.AddCommand(s_ipmoInfo)
+                    .AddParameter("ModuleInfo", module)
+                    .AddParameter("PassThru")
+                    .AddParameter("ErrorAction", "Stop")
+                    .InvokeAndClear<PSModuleInfo>()
+                    .FirstOrDefault();
+
+                Tuple<string, Version, ModuleData> moduleData = GetSingleModuleData(importedModule);
+
+                _pwsh.AddCommand(s_rmoInfo)
+                    .AddParameter("ModuleInfo", importedModule)
+                    .InvokeAndClear();
+
+                error = null;
+                return moduleData;
+            }
+            catch (RuntimeException e)
+            {
+                // A common problem is TypeData being hit with other modules, this overrides that
+                if (e.ErrorRecord.FullyQualifiedErrorId.Equals("FormatXmlUpdateException,Microsoft.PowerShell.Commands.ImportModuleCommand")
+                    || e.ErrorRecord.FullyQualifiedErrorId.Equals("ErrorsUpdatingTypes"))
                 {
-                    // Attempt to load the module in a new runspace instead
-                    try
-                    {
-                        using (SMA.PowerShell fallbackPwsh = SMA.PowerShell.Create(RunspaceMode.NewRunspace))
-                        {
-                            PSModuleInfo importedModule = fallbackPwsh.AddCommand(s_ipmoInfo)
-                                .AddParameter("Name", module.Path)
-                                .AddParameter("PassThru")
-                                .AddParameter("ErrorAction", "Stop")
-                                .InvokeAndClear<PSModuleInfo>()
-                                .FirstOrDefault();
-
-                            moduleDatas.Add(GetSingleModuleData(importedModule));
-                        }
-                    }
-                    catch (Exception fallbackException)
+                   foreach (string typeDataName in GetTypeDataNamesFromErrorMessage(e.Message))
+                   {
+                       _pwsh.AddCommand("Remove-TypeData")
+                            .AddParameter("TypeName", typeDataName)
+                            .InvokeAndClear();
+                   }
+                }
+
+                // Attempt to load the module in a new runspace instead
+                try
+                {
+                    using (SMA.PowerShell fallbackPwsh = SMA.PowerShell.Create(RunspaceMode.NewRunspace))
                     {
-                        errs.Add(fallbackException);
+                        PSModuleInfo importedModule = fallbackPwsh.AddCommand(s_ipmoInfo)
+                            .AddParameter("Name", module.Path)
+                            .AddParameter("PassThru")
+                            .AddParameter("Force")
+                            .AddParameter("ErrorAction", "Stop")
+                            .InvokeAndClear<PSModuleInfo>()
+                            .FirstOrDefault();
+
+                        error = null;
+                        return GetSingleModuleData(importedModule);
                     }
                 }
+                catch (Exception fallbackException)
+                {
+                    error = fallbackException;
+                    return null;
+                }
             }
-
-            errors = errs;
-            return moduleDatas;
         }
 
         public Tuple<string, Version, ModuleData> GetSingleModuleData(PSModuleInfo module)
@@ -191,9 +225,9 @@ public Tuple<string, Version, ModuleData> GetCoreModuleData()
                     .InvokeAndClear<PSVariable>();
 
                 var variableArray = new string[defaultVariables.Count];
-                for (int i = 0; i < moduleData.Variables.Length; i++)
+                for (int i = 0; i < variableArray.Length; i++)
                 {
-                    moduleData.Variables[i] = defaultVariables[i].Name;
+                    variableArray[i] = defaultVariables[i].Name;
                 }
                 moduleData.Variables = variableArray;
 
@@ -335,9 +369,16 @@ public FunctionData GetSingleFunctionData(FunctionInfo function)
                 CmdletBinding = function.CmdletBinding
             };
 
-            functionData.DefaultParameterSet = GetDefaultParameterSet(function.DefaultParameterSet);
-
-            functionData.OutputType = GetOutputType(function.OutputType);
+            try
+            {
+                functionData.DefaultParameterSet = GetDefaultParameterSet(function.DefaultParameterSet);
+                functionData.OutputType = GetOutputType(function.OutputType);
+            }
+            catch (RuntimeException)
+            {
+                // function.DefaultParameterSet can fail to do type resolution,
+                // in which case leave functionData.DefaultParameterSet null
+            }
 
             functionData.ParameterSets = GetParameterSets(function.ParameterSets);
 
@@ -471,6 +512,15 @@ private static ReadOnlySet<string> GetPowerShellCommonParameterNames()
             return new ReadOnlySet<string>(set, StringComparer.OrdinalIgnoreCase);
         }
 
+        private static string[] GetTypeDataNamesFromErrorMessage(string errorMessage)
+        {
+            var typeDataNames = new List<string>();
+            foreach (Match match in s_typeDataRegex.Matches(errorMessage))
+            {
+                typeDataNames.Add(match.Groups[1].Value);
+            }
+            return typeDataNames.ToArray();
+        }
 
         #region IDisposable Support
         private bool disposedValue = false; // To detect redundant calls

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Collection/TypeDataCollection.cs

@@ -94,7 +94,16 @@ public static AvailableTypeData AssembleAvailableTypes(
                     }
 
                     KeyValuePair<string, AssemblyData> asmData = AssembleAssembly(asm);
-                    asms[asmData.Key] = asmData.Value;
+                    try
+                    {
+                        asms.Add(asmData.Key, asmData.Value);
+                    }
+                    catch (ArgumentException e)
+                    {
+                        // We don't have a way in the schema for two assemblies with the same name, so we just keep the first
+                        // This is not really valid and we should update the schema to subkey the version
+                        errAcc.Add(new CompatibilityAnalysisException($"Found duplicate assemblies with name {asmData.Key}. Kept the first one.", e));
+                    }
                 }
                 catch (ReflectionTypeLoadException e)
                 {

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

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Management.Automation;
+using Microsoft.PowerShell.CrossCompatibility.Collection;
+using Microsoft.PowerShell.CrossCompatibility.Data;
+using Microsoft.PowerShell.CrossCompatibility.Utility;
+using Newtonsoft.Json;
+using SMA = System.Management.Automation;
+
+namespace Microsoft.PowerShell.CrossCompatibility.Commands
+{
+    /// <summary>
+    /// Creates a new PowerShell compatibility profile for the current PowerShell session
+    /// </summary>
+    [Cmdlet(VerbsCommon.New, CommandUtilities.ModulePrefix + "Profile", DefaultParameterSetName = "OutFile")]
+    public class NewPSCompatibilityProfileCommand : PSCmdlet
+    {
+        /// <summary>
+        /// The name of the default profile directory.
+        /// This directory lives in the module root.
+        /// </summary>
+        private const string DEFAULT_PROFILE_DIR_NAME = "profiles";
+
+        /// <summary>
+        /// The path of the profile file to create.
+        /// </summary>
+        [Parameter(ParameterSetName = "OutFile")]
+        public string OutFile { get; set; }
+
+        /// <summary>
+        /// When set, no file is created and the profile object is returned to the pipeline.
+        /// </summary>
+        /// <value></value>
+        [Parameter(ParameterSetName = "PassThru")]
+        public SwitchParameter PassThru { get; set; }
+
+        /// <summary>
+        /// When set, the profile is serialized with whitespace-formatted JSON.
+        /// </summary>
+        [Parameter(ParameterSetName = "OutFile")]
+        [Parameter(ParameterSetName = "ProfileName")]
+        public SwitchParameter NoCompress { get; set; }
+
+        /// <summary>
+        /// The ID of the platform to set in the profile.
+        /// If OutFile and ProfileName are not set, this will also be the filename of the profile.
+        /// </summary>
+        /// <value></value>
+        [Parameter]
+        public string PlatformId { get; set; }
+
+        /// <summary>
+        /// Sets the name of the profile file to be created in the default profile directory.
+        /// </summary>
+        [Parameter(ParameterSetName = "ProfileName")]
+        public string ProfileName { get; set; }
+
+        protected override void EndProcessing()
+        {
+            CompatibilityProfileData profile;
+            IEnumerable<Exception> errors;
+            using (var pwsh = SMA.PowerShell.Create())
+            using (var profileCollector = new CompatibilityProfileCollector(pwsh))
+            {
+                profile = string.IsNullOrEmpty(PlatformId)
+                    ? profileCollector.GetCompatibilityData(out errors)
+                    : profileCollector.GetCompatibilityData(PlatformId, out errors);
+            }
+
+            // Report any problems we hit
+            foreach (Exception e in errors)
+            {
+                WriteError(new ErrorRecord(e, "CompatibilityProfilerError", ErrorCategory.ReadError, null));
+            }
+
+            // If PassThru is set, just pass the object back and we're done
+            if (PassThru)
+            {
+                WriteObject(profile);
+                return;
+            }
+
+            // Set the default profile path if it was not provided
+            string outFilePath;
+            if (string.IsNullOrEmpty(OutFile))
+            {
+                string profileName = ProfileName ?? profile.Id;
+                outFilePath = GetDefaultProfilePath(profileName);
+            }
+            else
+            {
+                // Normalize the path to the output file we were given
+                outFilePath = SessionState.Path.GetUnresolvedProviderPathFromPSPath(OutFile);
+            }
+
+            // Create the directory containing the profile
+            // If it already exists, this call will do nothing
+            // If it cannot be created or is a non-directory file, an exception will be raised, which we let users handle
+            Directory.CreateDirectory(Path.GetDirectoryName(outFilePath));
+
+            // Create the JSON serializer
+            JsonProfileSerializer jsonSerializer = NoCompress
+                ? JsonProfileSerializer.Create(Formatting.Indented)
+                : JsonProfileSerializer.Create(Formatting.None);
+
+            // Write the file
+            var outFile = new FileInfo(outFilePath);
+            jsonSerializer.SerializeToFile(profile, outFile);
+
+            // Return the FileInfo object for the profile
+            WriteObject(outFile);
+        }
+
+        private string GetDefaultProfilePath(string profileName)
+        {
+            string moduleRoot = Path.GetDirectoryName(MyInvocation.MyCommand.Module.Path);
+            return Path.Combine(moduleRoot, DEFAULT_PROFILE_DIR_NAME, profileName + ".json");
+        }
+    }
+}

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Utility/JsonProfileSerializer.cs

@@ -123,6 +123,20 @@ public void SerializeToFile(object data, string filePath)
             }
         }
 
+        /// <summary>
+        /// Serialize a given .NET object to a given file, using the FileInfo representation of the file.
+        /// </summary>
+        /// <param name="data">The data object to serialize to JSON.</param>
+        /// <param name="file">The file to serialize to.</param>
+        public void SerializeToFile(object data, FileInfo file)
+        {
+            using (var fileStream = file.OpenRead())
+            using (var streamWriter = new StreamWriter(fileStream, Encoding.UTF8))
+            {
+                _serializer.Serialize(streamWriter, data);
+            }
+        }
+
         /// <summary>
         /// Hydrate a compatibility profile object from a given file.
         /// </summary>

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Utility/PowerShellExtensions.cs

@@ -8,16 +8,26 @@ internal static class PowerShellExtensions
     {
         public static Collection<PSObject> InvokeAndClear(this SMA.PowerShell pwsh)
         {
-            Collection<PSObject> result = pwsh.Invoke();
-            pwsh.Commands.Clear();
-            return result;
+            try
+            {
+                return pwsh.Invoke();
+            }
+            finally
+            {
+                pwsh.Commands.Clear();
+            }
         }
 
         public static Collection<T> InvokeAndClear<T>(this SMA.PowerShell pwsh)
         {
-            Collection<T> result = pwsh.Invoke<T>();
-            pwsh.Commands.Clear();
-            return result;
+            try
+            {
+                return pwsh.Invoke<T>();
+            }
+            finally
+            {
+                pwsh.Commands.Clear();
+            }
         }
     }
 }

PSCompatibilityAnalyzer/PSCompatibilityAnalyzer.psd1

@@ -40,8 +40,6 @@ PowerShellVersion = '3.0'
 
 # Functions to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no functions to export.
 FunctionsToExport = @(
-    'New-PowerShellCompatibilityProfile'
-    'Get-PlatformName'
     'ConvertTo-CompatibilityJson'
     'ConvertFrom-CompatibilityJson'
     'Get-PowerShellCompatibilityProfileData'
@@ -74,7 +72,10 @@ FunctionsToExport = @(
 )
 
 # Cmdlets to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no cmdlets to export.
-CmdletsToExport = @()
+CmdletsToExport = @(
+    'New-PSCompatibilityProfile'
+    'Get-PSCompatibilityPlatformName'
+)
 
 # Variables to export from this module
 VariablesToExport = @()