Fix #47: Add 'context' param to EvaluateRequest

This change adds the next 'context' parameter to EvaluateRequest, allowing
the debug adapter client to identify whether an 'evaluate' request will be
used for evaluating an expression for value display or REPL execution.
This allows us to write out REPL command output only when expressions are
being evaluated in that context.

Author: daviwil

src/PowerShellEditorServices.Protocol/DebugAdapter/EvaluateRequest.cs

@@ -16,17 +16,37 @@ public static readonly
 
     public class EvaluateRequestArguments
     {
+        /// <summary>
+        /// The expression to evaluate.
+        /// </summary>
         public string Expression { get; set; }
 
-    //        /** Evaluate the expression in the context of this stack frame. If not specified, the top most frame is used. */
+        /// <summary>
+        /// The context in which the evaluate request is run. Possible
+        /// values are 'watch' if evaluate is run in a watch or 'repl'
+        /// if run from the REPL console.
+        /// </summary>
+        public string Context { get; set; }
+
+        /// <summary>
+        /// Evaluate the expression in the context of this stack frame.
+        /// If not specified, the top most frame is used.
+        /// </summary>
         public int FrameId { get; set; }
     }
 
     public class EvaluateResponseBody
     {
+        /// <summary>
+        /// The evaluation result.
+        /// </summary>
         public string Result { get; set; }
 
-//            /** If variablesReference is > 0, the evaluate result is structured and its children can be retrieved by passing variablesReference to the VariablesRequest */
+        /// <summary>
+        /// If variablesReference is > 0, the evaluate result is
+        /// structured and its children can be retrieved by passing
+        /// variablesReference to the VariablesRequest
+        /// </summary>
         public int VariablesReference { get; set; }
     }
 }

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -312,10 +312,17 @@ protected async Task HandleEvaluateRequest(
             EvaluateRequestArguments evaluateParams,
             RequestContext<EvaluateResponseBody> requestContext)
         {
+            bool isFromRepl =
+                string.Equals(
+                    evaluateParams.Context,
+                    "repl",
+                    StringComparison.InvariantCultureIgnoreCase);
+
             VariableDetails result =
                 await editorSession.DebugService.EvaluateExpression(
                     evaluateParams.Expression,
-                    evaluateParams.FrameId);
+                    evaluateParams.FrameId,
+                    isFromRepl);
 
             string valueString = null;
             int variableId = 0;

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -679,6 +679,7 @@ protected async Task HandleEvaluateRequest(
             var results = 
                 await this.editorSession.PowerShellContext.ExecuteScriptString(
                     evaluateParams.Expression,
+                    true,
                     true);
 
             // Return an empty result since the result value is irrelevant

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -233,26 +233,38 @@ public VariableDetailsBase GetVariableFromExpression(string variableExpression,
         /// </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="writeResultAsOutput">
+        /// If true, writes the expression result as host output rather than returning the results.
+        /// In this case, the return value of this function will be null.</param>
         /// <returns>A VariableDetails object containing the result.</returns>
-        public async Task<VariableDetails> EvaluateExpression(string expressionString, int stackFrameId)
+        public async Task<VariableDetails> EvaluateExpression(
+            string expressionString,
+            int stackFrameId,
+            bool writeResultAsOutput)
         {
             var results = 
                 await this.powerShellContext.ExecuteScriptString(
                     expressionString,
-                    false);
+                    false,
+                    writeResultAsOutput);
 
             // 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.  However, if null is returned
-            // then pass null through so that no output gets displayed.
+            // then return null so that no output gets displayed.
             string outputString =
                 results != null ?
                     string.Join(Environment.NewLine, results) :
                     null;
 
-            return new VariableDetails(
-                expressionString,
-                outputString);
+            // If we've written the result as output, don't return a
+            // VariableDetails instance.
+            return
+                writeResultAsOutput ?
+                    null :
+                    new VariableDetails(
+                        expressionString,
+                        outputString);
         }
 
         /// <summary>

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -380,18 +380,20 @@ public Task ExecuteCommand(PSCommand psCommand)
         public Task<IEnumerable<object>> ExecuteScriptString(
             string scriptString)
         {
-            return this.ExecuteScriptString(scriptString, false);
+            return this.ExecuteScriptString(scriptString, false, true);
         }
 
         /// <summary>
         /// Executes a script string in the session's runspace.
         /// </summary>
         /// <param name="scriptString">The script string to execute.</param>
         /// <param name="writeInputToHost">If true, causes the script string to be written to the host.</param>
+        /// <param name="writeOutputToHost">If true, causes the script output to be written to the host.</param>
         /// <returns>A Task that can be awaited for the script completion.</returns>
         public async Task<IEnumerable<object>> ExecuteScriptString(
             string scriptString,
-            bool writeInputToHost)
+            bool writeInputToHost,
+            bool writeOutputToHost)
         {
             if (writeInputToHost)
             {
@@ -404,7 +406,7 @@ public async Task<IEnumerable<object>> ExecuteScriptString(
             PSCommand psCommand = new PSCommand();
             psCommand.AddScript(scriptString);
 
-            return await this.ExecuteCommand<object>(psCommand, true);
+            return await this.ExecuteCommand<object>(psCommand, writeOutputToHost);
         }
 
         /// <summary>