Rename PowerShellSession to PowerShellContext

This change renames the PowerShellSession class to PowerShellContext to
avoid confusion with the existing concept of a PSSession in PowerShell.

Author: daviwil

src/PowerShellEditorServices.Host/DebugAdapter.cs

@@ -101,7 +101,7 @@ protected async Task HandleLaunchRequest(
             // Execute the given PowerShell script and send the response.
             // Note that we aren't waiting for execution to complete here
             // because the debugger could stop while the script executes.
-            editorSession.PowerShellSession
+            editorSession.powerShellContext
                 .ExecuteScriptAtPath(launchParams.Program)
                 .ContinueWith(
                     async (t) =>
@@ -138,18 +138,18 @@ protected Task HandleDisconnectRequest(
             handler =
                 async (o, e) =>
                 {
-                    if (e.NewSessionState == PowerShellSessionState.Ready)
+                    if (e.NewSessionState == PowerShellContextState.Ready)
                     {
                         await requestContext.SendResult(null);
-                        editorSession.PowerShellSession.SessionStateChanged -= handler;
+                        editorSession.powerShellContext.SessionStateChanged -= handler;
 
                         // TODO: Find a way to exit more gracefully!
                         Environment.Exit(0);
                     }
                 };
 
-            editorSession.PowerShellSession.SessionStateChanged += handler;
-            editorSession.PowerShellSession.AbortExecution();
+            editorSession.powerShellContext.SessionStateChanged += handler;
+            editorSession.powerShellContext.AbortExecution();
 
             return Task.FromResult(true);
         }

src/PowerShellEditorServices.Host/LanguageServer.cs

@@ -366,7 +366,7 @@ protected async Task HandleCompletionResolveRequest(
             if (completionItem.Kind == CompletionItemKind.Function)
             {
                 RunspaceHandle runspaceHandle =
-                    await editorSession.PowerShellSession.GetRunspaceHandle();
+                    await editorSession.powerShellContext.GetRunspaceHandle();
 
                 // Get the documentation for the function
                 CommandInfo commandInfo = 

src/PowerShellEditorServices.Host/MessageLoop.cs

@@ -129,7 +129,7 @@ async Task ListenForMessages()
             // Set up the PowerShell session
             this.editorSession = new EditorSession();
             this.editorSession.StartSession(this.consoleHost);
-            this.editorSession.PowerShellSession.OutputWritten += PowerShellSession_OutputWritten;
+            this.editorSession.powerShellContext.OutputWritten += powerShellContext_OutputWritten;
 
             if (this.runDebugAdapter)
             {
@@ -191,7 +191,7 @@ await this.messageWriter.WriteEvent(
                 }, null);
         }
 
-        async void PowerShellSession_OutputWritten(object sender, OutputWrittenEventArgs e)
+        async void powerShellContext_OutputWritten(object sender, OutputWrittenEventArgs e)
         {
             await this.messageWriter.WriteEvent(
                 OutputEvent.Type,

src/PowerShellEditorServices/Analysis/AnalysisService.cs

@@ -32,7 +32,7 @@ public class AnalysisService : IDisposable
         /// </summary>
         public AnalysisService()
         {
-            // TODO: Share runspace with PowerShellSession?  Probably should always
+            // TODO: Share runspace with PowerShellContext?  Probably should always
             //       run analysis in a local session.
             this.analysisRunspace = RunspaceFactory.CreateRunspace(InitialSessionState.CreateDefault2());
             this.analysisRunspace.ApartmentState = ApartmentState.STA;

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -14,13 +14,13 @@ namespace Microsoft.PowerShell.EditorServices
 {
     /// <summary>
     /// Provides a high-level service for interacting with the
-    /// PowerShell debugger in the context of a PowerShellSession.
+    /// PowerShell debugger in the runspace managed by a PowerShellContext.
     /// </summary>
     public class DebugService
     {
         #region Fields
 
-        private PowerShellSession powerShellSession;
+        private PowerShellContext powerShellContext;
 
         // TODO: This needs to be managed per nested session
         private Dictionary<string, List<Breakpoint>> breakpointsPerFile = 
@@ -36,18 +36,18 @@ public class DebugService
 
         /// <summary>
         /// Initializes a new instance of the DebugService class and uses
-        /// the given PowerShellSession for all future operations.
+        /// the given PowerShellContext for all future operations.
         /// </summary>
-        /// <param name="powerShellSession">
-        /// The PowerShellSession to use for all debugging operations.
+        /// <param name="powerShellContext">
+        /// The PowerShellContext to use for all debugging operations.
         /// </param>
-        public DebugService(PowerShellSession powerShellSession)
+        public DebugService(PowerShellContext powerShellContext)
         {
-            Validate.IsNotNull("powerShellSession", powerShellSession);
+            Validate.IsNotNull("powerShellContext", powerShellContext);
 
-            this.powerShellSession = powerShellSession;
-            this.powerShellSession.DebuggerStop += this.OnDebuggerStop;
-            this.powerShellSession.BreakpointUpdated += this.OnBreakpointUpdated;
+            this.powerShellContext = powerShellContext;
+            this.powerShellContext.DebuggerStop += this.OnDebuggerStop;
+            this.powerShellContext.BreakpointUpdated += this.OnBreakpointUpdated;
         }
 
         #endregion
@@ -81,7 +81,7 @@ public async Task<BreakpointDetails[]> SetBreakpoints(
                 psCommand.AddParameter("Line", lineNumbers.Length > 0 ? lineNumbers : null);
 
                 resultBreakpoints =
-                    await this.powerShellSession.ExecuteCommand<Breakpoint>(
+                    await this.powerShellContext.ExecuteCommand<Breakpoint>(
                         psCommand);
 
                 return
@@ -98,7 +98,7 @@ await this.powerShellSession.ExecuteCommand<Breakpoint>(
         /// </summary>
         public void Continue()
         {
-            this.powerShellSession.ResumeDebugger(
+            this.powerShellContext.ResumeDebugger(
                 DebuggerResumeAction.Continue);
         }
 
@@ -107,7 +107,7 @@ public void Continue()
         /// </summary>
         public void StepOver()
         {
-            this.powerShellSession.ResumeDebugger(
+            this.powerShellContext.ResumeDebugger(
                 DebuggerResumeAction.StepOver);
         }
 
@@ -116,7 +116,7 @@ public void StepOver()
         /// </summary>
         public void StepIn()
         {
-            this.powerShellSession.ResumeDebugger(
+            this.powerShellContext.ResumeDebugger(
                 DebuggerResumeAction.StepInto);
         }
 
@@ -125,7 +125,7 @@ public void StepIn()
         /// </summary>
         public void StepOut()
         {
-            this.powerShellSession.ResumeDebugger(
+            this.powerShellContext.ResumeDebugger(
                 DebuggerResumeAction.StepOut);
         }
 
@@ -137,16 +137,16 @@ public void StepOut()
         public void Break()
         {
             // Break execution in the debugger
-            this.powerShellSession.BreakExecution();
+            this.powerShellContext.BreakExecution();
         }
 
         /// <summary>
         /// Aborts execution of the debugger while it is running, even while
-        /// it is stopped.  Equivalent to calling PowerShellSession.AbortExecution.
+        /// it is stopped.  Equivalent to calling PowerShellContext.AbortExecution.
         /// </summary>
         public void Abort()
         {
-            this.powerShellSession.AbortExecution();
+            this.powerShellContext.AbortExecution();
         }
 
         /// <summary>
@@ -238,15 +238,15 @@ public VariableDetails GetVariableFromExpression(string variableExpression, int
         /// <summary>
         /// Evaluates an expression in the context of the stopped
         /// debugger.  This method will execute the specified expression
-        /// PowerShellSession.
+        /// PowerShellContext.
         /// </summary>
         /// <param name="expressionString">The expression string to execute.</param>
         /// <param name="stackFrameId">The ID of the stack frame in which the expression should be executed.</param>
         /// <returns>A VariableDetails object containing the result.</returns>
         public async Task<VariableDetails> EvaluateExpression(string expressionString, int stackFrameId)
         {
             var results = 
-                await this.powerShellSession.ExecuteScriptString(
+                await this.powerShellContext.ExecuteScriptString(
                     expressionString);
 
             // Since this method should only be getting invoked in the debugger,
@@ -302,7 +302,7 @@ private async Task ClearBreakpointsInFile(ScriptFile scriptFile)
                     psCommand.AddCommand("Remove-PSBreakpoint");
                     psCommand.AddParameter("Breakpoint", breakpoints.ToArray());
 
-                    await this.powerShellSession.ExecuteCommand<object>(psCommand);
+                    await this.powerShellContext.ExecuteCommand<object>(psCommand);
 
                     // Clear the existing breakpoints list for the file
                     breakpoints.Clear();
@@ -319,7 +319,7 @@ private async Task FetchVariables()
             psCommand.AddCommand("Get-Variable");
             psCommand.AddParameter("Scope", "Local");
 
-            var results = await this.powerShellSession.ExecuteCommand<PSVariable>(psCommand);
+            var results = await this.powerShellContext.ExecuteCommand<PSVariable>(psCommand);
 
             foreach (var variable in results)
             {
@@ -336,7 +336,7 @@ private async Task FetchStackFrames()
             PSCommand psCommand = new PSCommand();
             psCommand.AddCommand("Get-PSCallStack");
 
-            var results = await this.powerShellSession.ExecuteCommand<CallStackFrame>(psCommand);
+            var results = await this.powerShellContext.ExecuteCommand<CallStackFrame>(psCommand);
 
             this.callStackFrames =
                 results

src/PowerShellEditorServices/Language/LanguageService.cs

@@ -23,7 +23,7 @@ public class LanguageService
         #region Private Fields
 
         private bool areAliasesLoaded;
-        private PowerShellSession powerShellSession;
+        private PowerShellContext powerShellContext;
         private CompletionResults mostRecentCompletions;
         private int mostRecentRequestLine;
         private int mostRecentRequestOffest;
@@ -39,14 +39,14 @@ public class LanguageService
         /// Constructs an instance of the LanguageService class and uses
         /// the given Runspace to execute language service operations.
         /// </summary>
-        /// <param name="powerShellSession">
-        /// The PowerShellSession in which language service operations will be executed.
+        /// <param name="powerShellContext">
+        /// The PowerShellContext in which language service operations will be executed.
         /// </param>
-        public LanguageService(PowerShellSession powerShellSession)
+        public LanguageService(PowerShellContext powerShellContext)
         {
-            Validate.IsNotNull("powerShellSession", powerShellSession);
+            Validate.IsNotNull("powerShellContext", powerShellContext);
 
-            this.powerShellSession = powerShellSession;
+            this.powerShellContext = powerShellContext;
 
             this.CmdletToAliasDictionary = new Dictionary<String, List<String>>(StringComparer.OrdinalIgnoreCase);
             this.AliasToCmdletDictionary = new Dictionary<String, String>(StringComparer.OrdinalIgnoreCase);
@@ -87,7 +87,7 @@ public async Task<CompletionResults> GetCompletionsInFile(
                     columnNumber);
 
             RunspaceHandle runspaceHandle =
-                await this.powerShellSession.GetRunspaceHandle();
+                await this.powerShellContext.GetRunspaceHandle();
 
             CompletionResults completionResults =
                 AstOperations.GetCompletions(
@@ -182,7 +182,7 @@ public async Task<SymbolDetails> FindSymbolDetailsAtLocation(
             if (symbolReference != null)
             {
                 RunspaceHandle runspaceHandle =
-                    await this.powerShellSession.GetRunspaceHandle();
+                    await this.powerShellContext.GetRunspaceHandle();
 
                 symbolReference.FilePath = scriptFile.FilePath;
                 symbolDetails = new SymbolDetails(symbolReference, runspaceHandle.Runspace);
@@ -432,7 +432,7 @@ private async Task GetAliases()
         {
             if (!this.areAliasesLoaded)
             {
-                RunspaceHandle runspaceHandle = await this.powerShellSession.GetRunspaceHandle();
+                RunspaceHandle runspaceHandle = await this.powerShellContext.GetRunspaceHandle();
 
                 CommandInvocationIntrinsics invokeCommand = runspaceHandle.Runspace.SessionStateProxy.InvokeCommand;
                 IEnumerable<CommandInfo> aliases = invokeCommand.GetCommands("*", CommandTypes.Alias, true);
@@ -463,7 +463,7 @@ private async Task<CommandInfo> GetCommandInfo(string commandName)
             command.AddCommand("Get-Command");
             command.AddArgument(commandName);
 
-            var results = await this.powerShellSession.ExecuteCommand<CommandInfo>(command);
+            var results = await this.powerShellContext.ExecuteCommand<CommandInfo>(command);
             return results.FirstOrDefault();
         }
 

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -90,8 +90,8 @@
     <Compile Include="Session\OutputType.cs" />
     <Compile Include="Session\OutputWrittenEventArgs.cs" />
     <Compile Include="Session\PowerShellExecutionResult.cs" />
-    <Compile Include="Session\PowerShellSession.cs" />
-    <Compile Include="Session\PowerShellSessionState.cs" />
+    <Compile Include="Session\PowerShellContext.cs" />
+    <Compile Include="Session\PowerShellContextState.cs" />
     <Compile Include="Session\ProgressDetails.cs" />
     <Compile Include="Session\RunspaceHandle.cs" />
     <Compile Include="Session\SessionPSHost.cs" />

src/PowerShellEditorServices/Session/EditorSession.cs

@@ -23,9 +23,9 @@ public class EditorSession
         public Workspace Workspace { get; private set; }
 
         /// <summary>
-        /// Gets the PowerShellSession instance for this session.
+        /// Gets the PowerShellContext instance for this session.
         /// </summary>
-        public PowerShellSession PowerShellSession { get; private set; }
+        public PowerShellContext powerShellContext { get; private set; }
 
         /// <summary>
         /// Gets the LanguageService instance for this session.
@@ -60,10 +60,10 @@ public void StartSession(IConsoleHost consoleHost)
             this.Workspace = new Workspace();
 
             // Initialize all services
-            this.PowerShellSession = new PowerShellSession();
-            this.LanguageService = new LanguageService(this.PowerShellSession);
+            this.powerShellContext = new PowerShellContext();
+            this.LanguageService = new LanguageService(this.powerShellContext);
             this.AnalysisService = new AnalysisService();
-            this.DebugService = new DebugService(this.PowerShellSession);
+            this.DebugService = new DebugService(this.powerShellContext);
         }
 
         #endregion
@@ -82,10 +82,10 @@ public void Dispose()
                 this.AnalysisService = null;
             }
 
-            if (this.PowerShellSession != null)
+            if (this.powerShellContext != null)
             {
-                this.PowerShellSession.Dispose();
-                this.PowerShellSession = null;
+                this.powerShellContext.Dispose();
+                this.powerShellContext = null;
             }
         }