Initialize runspaces with InitialSessionState object

Instead of passing values for `LanguageMode` and `ExecutionPolicy` as
fields that are set on an `InitialSessionState` object that's eventually
created, we now pass a fully initialized `InitialSessionState` object
from the start.

We also rename `SetExecutionPolicy` to `RestoreExecutionPolicy` to
reflect what it actually does: restores the user's policy after we
overrode it with `Bypass` while initializing the integrated console's
runspace. We override it because we need to be able to load `PSReadLine`
etc. without policy issues.

Finally, we fix the EditorConfig setting to enforce spaces after
control-flow keywords (such as `if`) because, while our codebase is
inconsistent, it is our preferred style going forward.

Author: dkattan

.editorconfig

@@ -11,7 +11,7 @@ insert_final_newline = true
 indent_size = 4
 trim_trailing_whitespace = true
 csharp_space_before_open_square_brackets = true
-csharp_space_after_keywords_in_control_flow_statements = false
+csharp_space_after_keywords_in_control_flow_statements = true
 
 [*.{json}]
 indent_size = 2

src/PowerShellEditorServices.Hosting/Commands/StartEditorServicesCommand.cs

@@ -349,15 +349,24 @@ private EditorServicesConfig CreateConfigObject()
             var profile = (PSObject)GetVariableValue("profile");
 
             var hostInfo = new HostInfo(HostName, HostProfileId, HostVersion);
-            var editorServicesConfig = new EditorServicesConfig(hostInfo, Host, SessionDetailsPath, bundledModulesPath, LogPath)
+
+            var initialSessionState = Runspace.DefaultRunspace.InitialSessionState;
+            initialSessionState.LanguageMode = Runspace.DefaultRunspace.SessionStateProxy.LanguageMode;
+
+            var editorServicesConfig = new EditorServicesConfig(
+                hostInfo,
+                Host,
+                SessionDetailsPath,
+                bundledModulesPath,
+                LogPath)
             {
                 FeatureFlags = FeatureFlags,
                 LogLevel = LogLevel,
                 ConsoleRepl = GetReplKind(),
                 AdditionalModules = AdditionalModules,
                 LanguageServiceTransport = GetLanguageServiceTransport(),
                 DebugServiceTransport = GetDebugServiceTransport(),
-                LanguageMode = Runspace.DefaultRunspace.SessionStateProxy.LanguageMode,
+                InitialSessionState = initialSessionState,
                 ProfilePaths = new ProfilePathConfig
                 {
                     AllUsersAllHosts = GetProfilePathFromProfileObject(profile, ProfileUserKind.AllUsers, ProfileHostKind.AllHosts),

src/PowerShellEditorServices.Hosting/Configuration/EditorServicesConfig.cs

@@ -2,8 +2,8 @@
 // Licensed under the MIT License.
 
 using System.Collections.Generic;
-using System.Management.Automation;
 using System.Management.Automation.Host;
+using System.Management.Automation.Runspaces;
 
 namespace Microsoft.PowerShell.EditorServices.Hosting
 {
@@ -111,10 +111,9 @@ public EditorServicesConfig(
         public ProfilePathConfig ProfilePaths { get; set; }
 
         /// <summary>
-        /// The language mode inherited from the orginal PowerShell process.
-        /// This will be used when creating runspaces so that we honor the same language mode.
+        /// The InitialSessionState to use when creating runspaces. LanguageMode can be set here.
         /// </summary>
-        public PSLanguageMode LanguageMode { get; internal set; }
+        public InitialSessionState InitialSessionState { get; internal set; }
 
         public string StartupBanner { get; set; } = @"
 

src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs

@@ -288,7 +288,7 @@ private HostStartupInfo CreateHostStartupInfo()
                 profilePaths,
                 _config.FeatureFlags,
                 _config.AdditionalModules,
-                _config.LanguageMode,
+                _config.InitialSessionState,
                 _config.LogPath,
                 (int)_config.LogLevel,
                 consoleReplEnabled: _config.ConsoleRepl != ConsoleReplKind.None,

src/PowerShellEditorServices/Hosting/HostStartupInfo.cs

@@ -3,8 +3,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Management.Automation;
 using System.Management.Automation.Host;
+using System.Management.Automation.Runspaces;
 
 namespace Microsoft.PowerShell.EditorServices.Hosting
 {
@@ -92,10 +92,10 @@ public sealed class HostStartupInfo
         public string LogPath { get; }
 
         /// <summary>
-        /// The language mode inherited from the orginal PowerShell process.
-        /// This will be used when creating runspaces so that we honor the same language mode.
+        /// The InitialSessionState will be inherited from the orginal PowerShell process. This will
+        /// be used when creating runspaces so that we honor the same InitialSessionState.
         /// </summary>
-        public PSLanguageMode LanguageMode { get; }
+        public InitialSessionState InitialSessionState { get; }
 
         /// <summary>
         /// The minimum log level of log events to be logged.
@@ -135,7 +135,7 @@ public sealed class HostStartupInfo
         /// <param name="currentUsersProfilePath">The path to the user specific profile.</param>
         /// <param name="featureFlags">Flags of features to enable.</param>
         /// <param name="additionalModules">Names or paths of additional modules to import.</param>
-        /// <param name="languageMode">The language mode inherited from the orginal PowerShell process. This will be used when creating runspaces so that we honor the same language mode.</param>
+        /// <param name="initialSessionState">The language mode inherited from the orginal PowerShell process. This will be used when creating runspaces so that we honor the same initialSessionState including allowed modules, cmdlets and language mode.</param>
         /// <param name="logPath">The path to log to.</param>
         /// <param name="logLevel">The minimum log event level.</param>
         /// <param name="consoleReplEnabled">Enable console if true.</param>
@@ -149,7 +149,7 @@ public HostStartupInfo(
             ProfilePathInfo profilePaths,
             IReadOnlyList<string> featureFlags,
             IReadOnlyList<string> additionalModules,
-            PSLanguageMode languageMode,
+            InitialSessionState initialSessionState,
             string logPath,
             int logLevel,
             bool consoleReplEnabled,
@@ -163,7 +163,7 @@ public HostStartupInfo(
             ProfilePaths = profilePaths;
             FeatureFlags = featureFlags ?? Array.Empty<string>();
             AdditionalModules = additionalModules ?? Array.Empty<string>();
-            LanguageMode = languageMode;
+            InitialSessionState = initialSessionState;
             LogPath = logPath;
             LogLevel = logLevel;
             ConsoleReplEnabled = consoleReplEnabled;

src/PowerShellEditorServices/Services/PowerShellContext/PowerShellContextService.cs

@@ -11,7 +11,6 @@
 using System.Management.Automation.Remoting;
 using System.Management.Automation.Runspaces;
 using System.Reflection;
-using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -230,7 +229,7 @@ public static PowerShellContextService Create(
                     logger);
 
             logger.LogTrace("Creating initial PowerShell runspace");
-            Runspace initialRunspace = PowerShellContextService.CreateRunspace(psHost, hostStartupInfo.LanguageMode);
+            Runspace initialRunspace = PowerShellContextService.CreateRunspace(psHost, hostStartupInfo.InitialSessionState);
             powerShellContext.Initialize(hostStartupInfo.ProfilePaths, initialRunspace, true, hostUserInterface);
             powerShellContext.ImportCommandsModuleAsync();
 
@@ -256,14 +255,17 @@ public static PowerShellContextService Create(
         }
 
         /// <summary>
-        ///
+        /// Only used in testing. Creates a Runspace given HostStartupInfo instead of a PSHost.
         /// </summary>
+        /// <remarks>
+        /// TODO: We should use `CreateRunspace` in testing instead of this, if possible.
+        /// </remarks>
         /// <param name="hostDetails"></param>
         /// <param name="powerShellContext"></param>
         /// <param name="hostUserInterface">The EditorServicesPSHostUserInterface to use for this instance.</param>
         /// <param name="logger">An ILogger implementation to use for this instance.</param>
         /// <returns></returns>
-        public static Runspace CreateRunspace(
+        public static Runspace CreateTestRunspace(
             HostStartupInfo hostDetails,
             PowerShellContextService powerShellContext,
             EditorServicesPSHostUserInterface hostUserInterface,
@@ -274,38 +276,17 @@ public static Runspace CreateRunspace(
             var psHost = new EditorServicesPSHost(powerShellContext, hostDetails, hostUserInterface, logger);
             powerShellContext.ConsoleWriter = hostUserInterface;
             powerShellContext.ConsoleReader = hostUserInterface;
-            return CreateRunspace(psHost, hostDetails.LanguageMode);
+            return CreateRunspace(psHost, hostDetails.InitialSessionState);
         }
 
         /// <summary>
         ///
         /// </summary>
         /// <param name="psHost">The PSHost that will be used for this Runspace.</param>
-        /// <param name="languageMode">The language mode inherited from the orginal PowerShell process. This will be used when creating runspaces so that we honor the same language mode.</param>
+        /// <param name="initialSessionState">This will be used when creating runspaces so that we honor the same InitialSessionState.</param>
         /// <returns></returns>
-        public static Runspace CreateRunspace(PSHost psHost, PSLanguageMode languageMode)
+        public static Runspace CreateRunspace(PSHost psHost, InitialSessionState initialSessionState)
         {
-            InitialSessionState initialSessionState;
-            if (Environment.GetEnvironmentVariable("PSES_TEST_USE_CREATE_DEFAULT") == "1") {
-                initialSessionState = InitialSessionState.CreateDefault();
-            } else {
-                initialSessionState = InitialSessionState.CreateDefault2();
-            }
-
-            // Create and initialize a new Runspace while honoring the LanguageMode of the original runspace
-            // that started PowerShell Editor Services. This is because the PowerShell Integrated Console
-            // should have the same LanguageMode of whatever is set by the system.
-            initialSessionState.LanguageMode = languageMode;
-
-            // We set the process scope's execution policy (which is really the runspace's scope) to
-            // Bypass so we can import our bundled modules. This is equivalent in scope to the CLI
-            // argument `-Bypass`, which (for instance) the extension passes. Thus we emulate this
-            // behavior for consistency such that unit tests can pass in a similar environment.
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                initialSessionState.ExecutionPolicy = ExecutionPolicy.Bypass;
-            }
-
             Runspace runspace = RunspaceFactory.CreateRunspace(psHost, initialSessionState);
 
             // Windows PowerShell must be hosted in STA mode
@@ -434,10 +415,9 @@ public void Initialize(
                 this.PromptContext = new LegacyReadLineContext(this);
             }
 
-            if (VersionUtils.IsWindows)
-            {
-                this.SetExecutionPolicy();
-            }
+            // Finally, restore the runspace's execution policy to the user's policy instead of
+            // Bypass.
+            this.RestoreExecutionPolicy();
         }
 
         /// <summary>
@@ -2152,9 +2132,20 @@ private static string GetStringForPSCommand(PSCommand psCommand)
             return stringBuilder.ToString();
         }
 
-        private void SetExecutionPolicy()
+        /// <summary>
+        /// This function restores the execution policy for the process by examining the user's
+        /// execution policy hierarchy. We do this because the process policy will always be set to
+        /// Bypass when initializing our runspaces.
+        /// </summary>
+        internal void RestoreExecutionPolicy()
         {
-            this.logger.LogTrace("Setting execution policy...");
+            // Execution policy is a Windows-only feature.
+            if (!VersionUtils.IsWindows)
+            {
+                return;
+            }
+
+            this.logger.LogTrace("Restoring execution policy...");
 
             // We want to get the list hierarchy of execution policies
             // Calling the cmdlet is the simplest way to do that

test/PowerShellEditorServices.Test/PowerShellContextFactory.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Management.Automation;
+using System.Management.Automation.Runspaces;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -13,6 +13,7 @@
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.PowerShellContext;
 using Microsoft.PowerShell.EditorServices.Test.Shared;
+using Microsoft.PowerShell.EditorServices.Utility;
 
 namespace Microsoft.PowerShell.EditorServices.Test
 {
@@ -40,6 +41,16 @@ internal static class PowerShellContextFactory
         public static PowerShellContextService Create(ILogger logger)
         {
             PowerShellContextService powerShellContext = new PowerShellContextService(logger, null, isPSReadLineEnabled: false);
+            var initialSessionState = InitialSessionState.CreateDefault();
+            // We set the process scope's execution policy (which is really the runspace's scope) to
+            // `Bypass` so we can import our bundled modules. This is equivalent in scope to the CLI
+            // argument `-ExecutionPolicy Bypass`, which (for instance) the extension passes. Thus
+            // we emulate this behavior for consistency such that unit tests can pass in a similar
+            // environment.
+            if (VersionUtils.IsWindows)
+            {
+                initialSessionState.ExecutionPolicy = ExecutionPolicy.Bypass;
+            }
 
             HostStartupInfo testHostDetails = new HostStartupInfo(
                 "PowerShell Editor Services Test Host",
@@ -49,16 +60,14 @@ public static PowerShellContextService Create(ILogger logger)
                 TestProfilePaths,
                 new List<string>(),
                 new List<string>(),
-                // TODO: We want to replace this property with an entire initial session state,
-                // which would then also control the process-scoped execution policy.
-                PSLanguageMode.FullLanguage,
+                initialSessionState,
                 null,
                 0,
                 consoleReplEnabled: false,
                 usesLegacyReadLine: false,
                 bundledModulePath: BundledModulePath);
 
-            InitialRunspace = PowerShellContextService.CreateRunspace(
+            InitialRunspace = PowerShellContextService.CreateTestRunspace(
                     testHostDetails,
                     powerShellContext,
                     new TestPSHostUserInterface(powerShellContext, logger),