PowerShell
diff --git a/‎.gitignore
+1 b/‎.gitignore
+1
diff --git a/‎PowerShellEditorServices.build.ps1
+19 b/‎PowerShellEditorServices.build.ps1
+19
diff --git a/‎appveyor.yml
+1 b/‎appveyor.yml
+1
diff --git a/‎module/PowerShellEditorServices/Start-EditorServices.ps1
+2-1 b/‎module/PowerShellEditorServices/Start-EditorServices.ps1
+2-1
diff --git a/‎src/PowerShellEditorServices.Host/EditorServicesHost.cs
+4-2 b/‎src/PowerShellEditorServices.Host/EditorServicesHost.cs
+4-2
diff --git a/‎src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs
+26-1 b/‎src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs
+26-1
diff --git a/‎src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
+9 b/‎src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
+9
diff --git a/‎src/PowerShellEditorServices/Console/ConsoleProxy.cs
+95 b/‎src/PowerShellEditorServices/Console/ConsoleProxy.cs
+95
diff --git a/‎src/PowerShellEditorServices/Console/ConsoleReadLine.cs
+32-26 b/‎src/PowerShellEditorServices/Console/ConsoleReadLine.cs
+32-26
@@ -29,6 +29,7 @@ registered_data.ini
 .dotnet/
 module/Plaster
 module/PSScriptAnalyzer
+module/PSReadLine
 docs/_site/
 docs/_repo/
 docs/metadata/
 
@@ -309,6 +309,25 @@ task RestorePsesModules -After Build {
 
         Save-Module @splatParameters
     }
+
+    # TODO: Replace this with adding a new module to Save when a new PSReadLine release comes out to the Gallery
+    if (-not (Test-Path $PSScriptRoot/module/PSReadLine))
+    {
+        Write-Host "`tInstalling module: PSReadLine"
+
+        # Download AppVeyor zip
+        $jobId = (Invoke-RestMethod https://ci.appveyor.com/api/projects/lzybkr/PSReadLine).build.jobs[0].jobId
+        Invoke-RestMethod https://ci.appveyor.com/api/buildjobs/$jobId/artifacts/bin%2FRelease%2FPSReadLine.zip -OutFile $PSScriptRoot/module/PSRL.zip
+
+        # Position PSReadLine
+        Expand-Archive $PSScriptRoot/module/PSRL.zip $PSScriptRoot/module/PSRL
+        Move-Item $PSScriptRoot/module/PSRL/PSReadLine $PSScriptRoot/module
+
+        # Clean up
+        Remove-Item -Force -Recurse $PSScriptRoot/module/PSRL.zip
+        Remove-Item -Force -Recurse $PSScriptRoot/module/PSRL
+    }
+
     Write-Host "`n"
 }
 
 
@@ -6,6 +6,7 @@ skip_tags: true
 branches:
   only:
   - master
+  - 2.0.0
 
 environment:
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true  # Don't download unneeded packages
 
@@ -314,7 +314,8 @@ try {
             -BundledModulesPath $BundledModulesPath `
             -EnableConsoleRepl:$EnableConsoleRepl.IsPresent `
             -DebugServiceOnly:$DebugServiceOnly.IsPresent `
-            -WaitForDebugger:$WaitForDebugger.IsPresent
+            -WaitForDebugger:$WaitForDebugger.IsPresent `
+            -FeatureFlags $FeatureFlags
 
     # TODO: Verify that the service is started
     Log "Start-EditorServicesHost returned $editorServicesHost"
 
@@ -365,7 +365,7 @@ private EditorSession CreateSession(
             bool enableConsoleRepl)
         {
             EditorSession editorSession = new EditorSession(this.logger);
-            PowerShellContext powerShellContext = new PowerShellContext(this.logger);
+            PowerShellContext powerShellContext = new PowerShellContext(this.logger, this.featureFlags.Contains("PSReadLine"));
 
             EditorServicesPSHostUserInterface hostUserInterface =
                 enableConsoleRepl
@@ -405,7 +405,9 @@ private EditorSession CreateDebugSession(
             bool enableConsoleRepl)
         {
             EditorSession editorSession = new EditorSession(this.logger);
-            PowerShellContext powerShellContext = new PowerShellContext(this.logger);
+            PowerShellContext powerShellContext = new PowerShellContext(
+                this.logger,
+                this.featureFlags.Contains("PSReadLine"));
 
             EditorServicesPSHostUserInterface hostUserInterface =
                 enableConsoleRepl
 
@@ -118,6 +118,17 @@ protected Task LaunchScript(RequestContext<object> requestContext)
 
         private async Task OnExecutionCompleted(Task executeTask)
         {
+            try
+            {
+                await executeTask;
+            }
+            catch (Exception e)
+            {
+                Logger.Write(
+                    LogLevel.Error,
+                    "Exception occurred while awaiting debug launch task.\n\n" + e.ToString());
+            }
+
             Logger.Write(LogLevel.Verbose, "Execution completed, terminating...");
 
             this.executionCompleted = true;
@@ -470,7 +481,7 @@ protected async Task HandleDisconnectRequest(
                 if (this.executionCompleted == false)
                 {
                     this.disconnectRequestContext = requestContext;
-                    this.editorSession.PowerShellContext.AbortExecution();
+                    this.editorSession.PowerShellContext.AbortExecution(shouldAbortDebugSession: true);
 
                     if (this.isInteractiveDebugSession)
                     {
@@ -755,6 +766,20 @@ protected async Task HandleStackTraceRequest(
             StackFrameDetails[] stackFrames =
                 editorSession.DebugService.GetStackFrames();
 
+            // Handle a rare race condition where the adapter requests stack frames before they've
+            // begun building.
+            if (stackFrames == null)
+            {
+                await requestContext.SendResult(
+                    new StackTraceResponseBody
+                    {
+                        StackFrames = new StackFrame[0],
+                        TotalFrames = 0
+                    });
+
+                return;
+            }
+
             List<StackFrame> newStackFrames = new List<StackFrame>();
 
             int startFrameIndex = stackTraceParams.StartFrame ?? 0;
 
@@ -1502,6 +1502,15 @@ private static async Task DelayThenInvokeDiagnostics(
             catch (TaskCanceledException)
             {
                 // If the task is cancelled, exit directly
+                foreach (var script in filesToAnalyze)
+                {
+                    await PublishScriptDiagnostics(
+                        script,
+                        script.SyntaxMarkers,
+                        correctionIndex,
+                        eventSender);
+                }
+
                 return;
             }
 
 
@@ -0,0 +1,95 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerShell.EditorServices.Console
+{
+    /// <summary>
+    /// Provides asynchronous implementations of the <see cref="Console" /> API's as well as
+    /// synchronous implementations that work around platform specific issues.
+    /// </summary>
+    internal static class ConsoleProxy
+    {
+        private static IConsoleOperations s_consoleProxy;
+
+        static ConsoleProxy()
+        {
+            // Maybe we should just include the RuntimeInformation package for FullCLR?
+#if CoreCLR
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                s_consoleProxy = new WindowsConsoleOperations();
+                return;
+            }
+
+            s_consoleProxy = new UnixConsoleOperations();
+#else
+            s_consoleProxy = new WindowsConsoleOperations();
+#endif
+        }
+
+        public static Task<ConsoleKeyInfo> ReadKeyAsync(CancellationToken cancellationToken) =>
+            s_consoleProxy.ReadKeyAsync(cancellationToken);
+
+        public static int GetCursorLeft() =>
+            s_consoleProxy.GetCursorLeft();
+
+        public static int GetCursorLeft(CancellationToken cancellationToken) =>
+            s_consoleProxy.GetCursorLeft(cancellationToken);
+
+        public static Task<int> GetCursorLeftAsync() =>
+            s_consoleProxy.GetCursorLeftAsync();
+
+        public static Task<int> GetCursorLeftAsync(CancellationToken cancellationToken) =>
+            s_consoleProxy.GetCursorLeftAsync(cancellationToken);
+
+        public static int GetCursorTop() =>
+            s_consoleProxy.GetCursorTop();
+
+        public static int GetCursorTop(CancellationToken cancellationToken) =>
+            s_consoleProxy.GetCursorTop(cancellationToken);
+
+        public static Task<int> GetCursorTopAsync() =>
+            s_consoleProxy.GetCursorTopAsync();
+
+        public static Task<int> GetCursorTopAsync(CancellationToken cancellationToken) =>
+            s_consoleProxy.GetCursorTopAsync(cancellationToken);
+
+        /// <summary>
+        /// On Unix platforms this method is sent to PSReadLine as a work around for issues
+        /// with the System.Console implementation for that platform. Functionally it is the
+        /// same as System.Console.ReadKey, with the exception that it will not lock the
+        /// standard input stream.
+        /// </summary>
+        /// <param name="intercept">
+        /// Determines whether to display the pressed key in the console window.
+        /// true to not display the pressed key; otherwise, false.
+        /// </param>
+        /// <param name="cancellationToken">
+        /// The <see cref="CancellationToken" /> that can be used to cancel the request.
+        /// </param>
+        /// <returns>
+        /// An object that describes the ConsoleKey constant and Unicode character, if any,
+        /// that correspond to the pressed console key. The ConsoleKeyInfo object also describes,
+        /// in a bitwise combination of ConsoleModifiers values, whether one or more Shift, Alt,
+        /// or Ctrl modifier keys was pressed simultaneously with the console key.
+        /// </returns>
+        internal static ConsoleKeyInfo UnixReadKey(bool intercept, CancellationToken cancellationToken)
+        {
+            try
+            {
+                return ((UnixConsoleOperations)s_consoleProxy).ReadKey(intercept, cancellationToken);
+            }
+            catch (OperationCanceledException)
+            {
+                return default(ConsoleKeyInfo);
+            }
+        }
+    }
+}
@@ -6,7 +6,6 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -20,27 +19,13 @@ namespace Microsoft.PowerShell.EditorServices.Console
     internal class ConsoleReadLine
     {
         #region Private Field
-        private static IConsoleOperations s_consoleProxy;
-
         private PowerShellContext powerShellContext;
 
         #endregion
 
         #region Constructors
         static ConsoleReadLine()
         {
-            // Maybe we should just include the RuntimeInformation package for FullCLR?
-            #if CoreCLR
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                s_consoleProxy = new WindowsConsoleOperations();
-                return;
-            }
-
-            s_consoleProxy = new UnixConsoleOperations();
-            #else
-            s_consoleProxy = new WindowsConsoleOperations();
-            #endif
         }
 
         public ConsoleReadLine(PowerShellContext powerShellContext)
@@ -54,20 +39,20 @@ public ConsoleReadLine(PowerShellContext powerShellContext)
 
         public Task<string> ReadCommandLine(CancellationToken cancellationToken)
         {
-            return this.ReadLine(true, cancellationToken);
+            return this.ReadLineAsync(true, cancellationToken);
         }
 
         public Task<string> ReadSimpleLine(CancellationToken cancellationToken)
         {
-            return this.ReadLine(false, cancellationToken);
+            return this.ReadLineAsync(false, cancellationToken);
         }
 
         public async Task<SecureString> ReadSecureLine(CancellationToken cancellationToken)
         {
             SecureString secureString = new SecureString();
 
-            int initialPromptRow = Console.CursorTop;
-            int initialPromptCol = Console.CursorLeft;
+            int initialPromptRow = await ConsoleProxy.GetCursorTopAsync(cancellationToken);
+            int initialPromptCol = await ConsoleProxy.GetCursorLeftAsync(cancellationToken);
             int previousInputLength = 0;
 
             Console.TreatControlCAsInput = true;
@@ -114,7 +99,8 @@ public async Task<SecureString> ReadSecureLine(CancellationToken cancellationTok
                     }
                     else if (previousInputLength > 0 && currentInputLength < previousInputLength)
                     {
-                        int row = Console.CursorTop, col = Console.CursorLeft;
+                        int row = await ConsoleProxy.GetCursorTopAsync(cancellationToken);
+                        int col = await ConsoleProxy.GetCursorLeftAsync(cancellationToken);
 
                         // Back up the cursor before clearing the character
                         col--;
@@ -146,10 +132,30 @@ public async Task<SecureString> ReadSecureLine(CancellationToken cancellationTok
 
         private static async Task<ConsoleKeyInfo> ReadKeyAsync(CancellationToken cancellationToken)
         {
-            return await s_consoleProxy.ReadKeyAsync(cancellationToken);
+            return await ConsoleProxy.ReadKeyAsync(cancellationToken);
+        }
+
+        private async Task<string> ReadLineAsync(bool isCommandLine, CancellationToken cancellationToken)
+        {
+            return await this.powerShellContext.InvokeReadLineAsync(isCommandLine, cancellationToken);
         }
 
-        private async Task<string> ReadLine(bool isCommandLine, CancellationToken cancellationToken)
+        /// <summary>
+        /// Invokes a custom ReadLine method that is similar to but more basic than PSReadLine.
+        /// This method should be used when PSReadLine is disabled, either by user settings or
+        /// unsupported PowerShell versions.
+        /// </summary>
+        /// <param name="isCommandLine">
+        /// Indicates whether ReadLine should act like a command line.
+        /// </param>
+        /// <param name="cancellationToken">
+        /// The cancellation token that will be checked prior to completing the returned task.
+        /// </param>
+        /// <returns>
+        /// A task object representing the asynchronus operation. The Result property on
+        /// the task object returns the user input string.
+        /// </returns>
+        internal async Task<string> InvokeLegacyReadLineAsync(bool isCommandLine, CancellationToken cancellationToken)
         {
             string inputBeforeCompletion = null;
             string inputAfterCompletion = null;
@@ -160,8 +166,8 @@ private async Task<string> ReadLine(bool isCommandLine, CancellationToken cancel
 
             StringBuilder inputLine = new StringBuilder();
 
-            int initialCursorCol = Console.CursorLeft;
-            int initialCursorRow = Console.CursorTop;
+            int initialCursorCol = await ConsoleProxy.GetCursorLeftAsync(cancellationToken);
+            int initialCursorRow = await ConsoleProxy.GetCursorTopAsync(cancellationToken);
 
             int initialWindowLeft = Console.WindowLeft;
             int initialWindowTop = Console.WindowTop;
@@ -492,8 +498,8 @@ private int CalculateIndexFromCursor(
             int consoleWidth)
         {
             return
-                ((Console.CursorTop - promptStartRow) * consoleWidth) +
-                Console.CursorLeft - promptStartCol;
+                ((ConsoleProxy.GetCursorTop() - promptStartRow) * consoleWidth) +
+                ConsoleProxy.GetCursorLeft() - promptStartCol;
         }
 
         private void CalculateCursorFromIndex(