Improve reliability of execution on pipeline thread while debugging

This change improves reliability of command execution on the pipeline
thread when stopped at a breakpoint in the debugger.  Previously there
was a global task variable used to propagate execution results back to
the caller of ExecuteCommand, but now we use a specific task variable
that's tied to the original ExecuteCommand call to avoid reuse of the
global task.

Author: daviwil

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -45,7 +45,6 @@ public class PowerShellContext : IDisposable, IHostSupportsInteractiveSession
         private int pipelineThreadId;
         private TaskCompletionSource<DebuggerResumeAction> debuggerStoppedTask;
         private TaskCompletionSource<IPipelineExecutionRequest> pipelineExecutionTask;
-        private TaskCompletionSource<IPipelineExecutionRequest> pipelineResultTask;
 
         private object runspaceMutex = new object();
         private AsyncQueue<RunspaceHandle> runspaceWaitQueue = new AsyncQueue<RunspaceHandle>();
@@ -414,11 +413,9 @@ public async Task<IEnumerable<TResult>> ExecuteCommand<TResult>(
                         executionOptions.WriteOutputToHost);
 
                 // Send the pipeline execution request to the pipeline thread
-                this.pipelineResultTask = new TaskCompletionSource<IPipelineExecutionRequest>();
                 this.pipelineExecutionTask.SetResult(executionRequest);
 
-                await this.pipelineResultTask.Task;
-                return executionRequest.Results;
+                return await executionRequest.Results;
             }
             else
             {
@@ -1653,8 +1650,6 @@ private void OnDebuggerStop(object sender, DebuggerStopEventArgs e)
 
                     Logger.Write(LogLevel.Verbose, "Pipeline thread execution completed.");
 
-                    this.pipelineResultTask.SetResult(executionRequest);
-
                     if (this.CurrentRunspace.Runspace.RunspaceAvailability == RunspaceAvailability.Available)
                     {
                         if (this.CurrentRunspace.Context == RunspaceContext.DebuggedRunspace)
@@ -1711,8 +1706,12 @@ private class PipelineExecutionRequest<TResult> : IPipelineExecutionRequest
             PSCommand psCommand;
             StringBuilder errorMessages;
             bool sendOutputToHost;
+            TaskCompletionSource<IEnumerable<TResult>> resultsTask;
 
-            public IEnumerable<TResult> Results { get; private set; }
+            public Task<IEnumerable<TResult>> Results
+            {
+                get { return this.resultsTask.Task; }
+            }
 
             public PipelineExecutionRequest(
                 PowerShellContext powerShellContext,
@@ -1724,16 +1723,19 @@ public PipelineExecutionRequest(
                 this.psCommand = psCommand;
                 this.errorMessages = errorMessages;
                 this.sendOutputToHost = sendOutputToHost;
+                this.resultsTask = new TaskCompletionSource<IEnumerable<TResult>>();
             }
 
             public async Task Execute()
             {
-                this.Results =
+                var results =
                     await this.powerShellContext.ExecuteCommand<TResult>(
                         psCommand,
                         errorMessages,
                         sendOutputToHost);
 
+                this.resultsTask.SetResult(results);
+
                 // TODO: Deal with errors?
             }
         }