Improve PowerShell version and architecture gathering

This change makes some slight tweaks to the PowerShell version and
architecture gathering code to improve the user experience in the host
editors which display those values.

Author: daviwil

src/PowerShellEditorServices.Protocol/LanguageServer/PowerShellVersionRequest.cs

@@ -31,10 +31,22 @@ public PowerShellVersionResponse()
 
         public PowerShellVersionResponse(PowerShellVersionDetails versionDetails)
         {
-            this.Version = versionDetails.Version.ToString();
-            this.DisplayVersion = versionDetails.VersionString;
+            this.Version = versionDetails.VersionString;
+            this.DisplayVersion =  $"{versionDetails.Version.Major}.{versionDetails.Version.Minor}";
             this.Edition = versionDetails.Edition;
-            this.Architecture = versionDetails.Architecture;
+
+            switch (versionDetails.Architecture)
+            {
+                case PowerShellProcessArchitecture.X64:
+                    this.Architecture = "x64";
+                    break;
+                case PowerShellProcessArchitecture.X86:
+                    this.Architecture = "x86";
+                    break;
+                default:
+                    this.Architecture = "Architecture Unknown";
+                    break;
+            }
         }
     }
 }

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -257,32 +257,52 @@ private PowerShellVersionDetails GetPowerShellVersion()
             Version powerShellVersion = new Version(5, 0);
             string versionString = null;
             string powerShellEdition = "Desktop";
-            string architecture = "Unknown";
+            var architecture = PowerShellProcessArchitecture.Unknown;
 
             try
             {
                 var psVersionTable = this.currentRunspace.SessionStateProxy.GetVariable("PSVersionTable") as Hashtable;
                 if (psVersionTable != null)
                 {
-                    var version = psVersionTable["PSVersion"] as Version;
-                    if (version != null)
-                    {
-                        powerShellVersion = version;
-                    }
-
                     var edition = psVersionTable["PSEdition"] as string;
                     if (edition != null)
                     {
                         powerShellEdition = edition;
                     }
 
+                    // The PSVersion value will either be of Version or SemanticVersion.
+                    // In the former case, take the value directly.  In the latter case,
+                    // generate a Version from its string representation.
+                    var version = psVersionTable["PSVersion"];
+                    if (version is Version)
+                    {
+                        powerShellVersion = (Version)version;
+                    }
+                    else if (string.Equals(powerShellEdition, "Core", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        // Expected version string format is 6.0.0-alpha so build a simpler version from that
+                        powerShellVersion = new Version(version.ToString().Split('-')[0]);
+                    }
+
                     var gitCommitId = psVersionTable["GitCommitId"] as string;
                     if (gitCommitId != null)
                     {
                         versionString = gitCommitId;
                     }
+                    else
+                    {
+                        versionString = powerShellVersion.ToString();
+                    }
 
-                    architecture = this.currentRunspace.SessionStateProxy.GetVariable("env:PROCESSOR_ARCHITECTURE") as string;
+                    var arch = this.currentRunspace.SessionStateProxy.GetVariable("env:PROCESSOR_ARCHITECTURE") as string;
+                    if (string.Equals(arch, "AMD64", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        architecture = PowerShellProcessArchitecture.X64;
+                    }
+                    else if (string.Equals(arch, "x86", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        architecture = PowerShellProcessArchitecture.X86;
+                    }
                 }
             }
             catch (Exception ex)

src/PowerShellEditorServices/Session/PowerShellVersionDetails.cs

@@ -7,6 +7,27 @@
 
 namespace Microsoft.PowerShell.EditorServices.Session
 {
+    /// <summary>
+    /// Defines the possible enumeration values for the PowerShell process architecture.
+    /// </summary>
+    public enum PowerShellProcessArchitecture
+    {
+        /// <summary>
+        /// The processor architecture is unknown or wasn't accessible.
+        /// </summary>
+        Unknown,
+
+        /// <summary>
+        /// The processor architecture is 32-bit.
+        /// </summary>
+        X86,
+
+        /// <summary>
+        /// The processor architecture is 64-bit.
+        /// </summary>
+        X64
+    }
+
     /// <summary>
     /// Provides details about the version of the PowerShell runtime.
     /// </summary>
@@ -29,31 +50,27 @@ public class PowerShellVersionDetails
         public string Edition { get; private set; }
 
         /// <summary>
-        /// Gets the architecture of the PowerShell process, either "x86" or
-        /// "x64".
+        /// Gets the architecture of the PowerShell process.
         /// </summary>
-        public string Architecture { get; private set; }
+        public PowerShellProcessArchitecture Architecture { get; private set; }
 
         /// <summary>
         /// Creates an instance of the PowerShellVersionDetails class.
         /// </summary>
-        /// <param name="powerShellVersion">The version of the PowerShell runtime.</param>
+        /// <param name="version">The version of the PowerShell runtime.</param>
         /// <param name="versionString">A string representation of the PowerShell version.</param>
         /// <param name="editionString">The string representation of the PowerShell edition.</param>
-        /// <param name="architectureString">The string representation of the processor architecture.</param>
+        /// <param name="architecture">The processor architecture.</param>
         public PowerShellVersionDetails(
-            Version powerShellVersion,
+            Version version,
             string versionString,
             string editionString,
-            string architectureString)
+            PowerShellProcessArchitecture architecture)
         {
-            this.Version = powerShellVersion;
-            this.VersionString = versionString ?? $"{powerShellVersion.Major}.{powerShellVersion.Minor}";
+            this.Version = version;
+            this.VersionString = versionString;
             this.Edition = editionString;
-            this.Architecture =
-                string.Equals(architectureString, "AMD64", StringComparison.CurrentCultureIgnoreCase)
-                    ? "x64"
-                    : architectureString;
+            this.Architecture = architecture;
         }
     }
 }