Merge pull request #307 from PowerShell/daviwil/session-version-fixes

Improve PowerShell version and architecture gathering

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;
         }
     }
 }