Introduce OutputEvent and command eval in debugger

This change introduces the new OutputEvent which allows the the language
and debugging services to send script output text to the client to be
displayed to the user.  Currently this is used in VS Code's Debug Console
but could be used in other contexts as well.

This change also enables the user to evaluate PowerShell commands while
stopped in the debugger to aid in debugging.  In the future this will be
expanded to allow commands to be executed at any time.

Author: daviwil

src/PowerShellEditorServices.Host/MessageLoop.cs

@@ -183,22 +183,17 @@ await this.messageWriter.WriteMessage(
                 }, null);
         }
 
-        void PowerShellSession_OutputWritten(object sender, OutputWrittenEventArgs e)
+        async void PowerShellSession_OutputWritten(object sender, OutputWrittenEventArgs e)
         {
-            // TODO: change this to use the OutputEvent!
-
-            //await this.messageWriter.WriteMessage(
-            //    new ReplWriteOutputEvent
-            //    {
-            //        Body = new ReplWriteOutputEventBody
-            //        {
-            //            LineContents = e.OutputText,
-            //            LineType = e.OutputType,
-            //            IncludeNewLine = e.IncludeNewLine,
-            //            ForegroundColor = e.ForegroundColor,
-            //            BackgroundColor = e.BackgroundColor
-            //        }
-            //    });
+            await this.messageWriter.WriteMessage(
+                new OutputEvent
+                {
+                    Body = new OutputEventBody
+                    {
+                        Output = e.OutputText + (e.IncludeNewLine ? "\r\n" : string.Empty),
+                        Category = (e.OutputType == OutputType.Error) ? "stderr" : "stdout"
+                    }
+                });
         }
 
         #endregion

src/PowerShellEditorServices.Transport.Stdio/Event/OutputEvent.cs

@@ -0,0 +1,27 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Transport.Stdio.Message;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerShell.EditorServices.Transport.Stdio.Event
+{
+    [MessageTypeName("output")]
+    public class OutputEvent : EventBase<OutputEventBody>
+    {
+    }
+
+    public class OutputEventBody
+    {
+        public string Category { get; set; }
+
+        public string Output { get; set; }
+    }
+}
+

src/PowerShellEditorServices.Transport.Stdio/PowerShellEditorServices.Transport.Stdio.csproj

@@ -64,6 +64,7 @@
     <Compile Include="Event\EventBase.cs" />
     <Compile Include="Event\ExitedEvent.cs" />
     <Compile Include="Event\InitializedEvent.cs" />
+    <Compile Include="Event\OutputEvent.cs" />
     <Compile Include="Event\ReplPromptChoiceEvent.cs">
       <SubType>Code</SubType>
     </Compile>

src/PowerShellEditorServices.Transport.Stdio/Request/EvaluateRequest.cs

@@ -18,7 +18,7 @@ public override async Task ProcessMessage(
             MessageWriter messageWriter)
         {
             VariableDetails result =
-                editorSession.DebugService.EvaluateExpression(
+                await editorSession.DebugService.EvaluateExpression(
                     this.Arguments.Expression,
                     this.Arguments.FrameId);
 

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -193,18 +193,17 @@ public VariableDetails[] GetVariables(int variableReferenceId)
         }
 
         /// <summary>
-        /// Evaluates an expression in the context of the stopped
-        /// debugger.  For now, this just does simple evaluation of
-        /// a variable in the session.  In the future it will execute
-        /// commands in the PowerShellSession.
+        /// Evaluates a variable expression in the context of the stopped
+        /// debugger.  This method decomposes the variable expression to
+        /// walk the cached variable data for the specified stack frame.
         /// </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>
+        /// <param name="variableExpression">The variable expression string to evaluate.</param>
+        /// <param name="stackFrameId">The ID of the stack frame in which the expression should be evaluated.</param>
         /// <returns>A VariableDetails object containing the result.</returns>
-        public VariableDetails EvaluateExpression(string expressionString, int stackFrameId)
+        public VariableDetails GetVariableFromExpression(string variableExpression, int stackFrameId)
         {
             // Break up the variable path
-            string[] variablePathParts = expressionString.Split('.');
+            string[] variablePathParts = variableExpression.Split('.');
 
             VariableDetails resolvedVariable = null;
             IEnumerable<VariableDetails> variableList = this.currentVariables;
@@ -222,10 +221,10 @@ public VariableDetails EvaluateExpression(string expressionString, int stackFram
                         v =>
                             string.Equals(
                                 v.Name,
-                                expressionString,
+                                variableExpression,
                                 StringComparison.InvariantCultureIgnoreCase));
 
-                if (resolvedVariable != null && 
+                if (resolvedVariable != null &&
                     resolvedVariable.IsExpandable)
                 {
                     // Continue by searching in this variable's children
@@ -236,6 +235,29 @@ public VariableDetails EvaluateExpression(string expressionString, int stackFram
             return resolvedVariable;
         }
 
+        /// <summary>
+        /// Evaluates an expression in the context of the stopped
+        /// debugger.  This method will execute the specified expression
+        /// PowerShellSession.
+        /// </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(
+                    expressionString);
+
+            // Since this method should only be getting invoked in the debugger,
+            // we can assume that Out-String will be getting used to format results
+            // of command executions into string output.
+
+            return new VariableDetails(
+                expressionString, 
+                string.Join(Environment.NewLine, results));
+        }
+
         /// <summary>
         /// Gets the list of stack frames at the point where the
         /// debugger sf stopped.

src/PowerShellEditorServices/Session/PowerShellSession.cs

@@ -310,12 +310,12 @@ public Task ExecuteCommand(PSCommand psCommand)
         /// </summary>
         /// <param name="scriptString">The script string to execute.</param>
         /// <returns>A Task that can be awaited for the script completion.</returns>
-        public async Task ExecuteScriptString(string scriptString)
+        public async Task<IEnumerable<object>> ExecuteScriptString(string scriptString)
         {
             PSCommand psCommand = new PSCommand();
             psCommand.AddScript(scriptString);
 
-            await this.ExecuteCommand<object>(psCommand, true);
+            return await this.ExecuteCommand<object>(psCommand, true);
         }
 
         /// <summary>
@@ -328,7 +328,7 @@ public async Task ExecuteScriptAtPath(string scriptPath)
             PSCommand command = new PSCommand();
             command.AddCommand(scriptPath);
 
-            await this.ExecuteCommand<object>(command);
+            await this.ExecuteCommand<object>(command, true);
         }
 
         /// <summary>

test/PowerShellEditorServices.Test.Host/ScenarioTests.cs

@@ -371,20 +371,21 @@ await this.MessageWriter.WriteMessage(
             Assert.Equal(sigHelp.Body.ArgumentCount, 1);
         }
 
-        [Fact(Skip = "Console output events are disabled until we migrate to the updated debug protocol.")]
+        [Fact]
         public async Task ServiceExecutesReplCommandAndReceivesOutput()
         {
             await this.MessageWriter.WriteMessage(
-                new ReplExecuteRequest
+                new EvaluateRequest
                 {
-                    Arguments = new ReplExecuteArgs
+                    Arguments = new EvaluateRequestArguments
                     {
-                        CommandString = "1 + 2"
+                        Expression = "1 + 2"
                     }
                 });
 
-            ReplWriteOutputEvent replWriteLineEvent = this.WaitForMessage<ReplWriteOutputEvent>();
-            Assert.Equal("3", replWriteLineEvent.Body.LineContents);
+            OutputEvent outputEvent = this.WaitForMessage<OutputEvent>();
+            Assert.Equal("3\r\n", outputEvent.Body.Output);
+            Assert.Equal("stdout", outputEvent.Body.Category);
         }
 
         [Fact(Skip = "Choice prompt functionality is currently in transition to a new model.")]