WIP: Testing readkey workarounds

Author: andyleejordan

PowerShellEditorServices.Common.props

@@ -5,6 +5,7 @@
     <Company>Microsoft</Company>
     <Copyright>© Microsoft Corporation.</Copyright>
     <LangVersion>latest</LangVersion>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <PackageTags>PowerShell;editor;development;language;debugging</PackageTags>
     <PackageLicenseUrl>https://raw.githubusercontent.com/PowerShell/PowerShellEditorServices/master/LICENSE</PackageLicenseUrl>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>

src/PowerShellEditorServices/Services/PowerShell/Console/ConsoleProxy.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
 {
@@ -14,6 +13,13 @@ namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
     /// </summary>
     internal static class ConsoleProxy
     {
+        internal static readonly ConsoleKeyInfo s_nullKeyInfo = new(
+            keyChar: ' ',
+            ConsoleKey.DownArrow,
+            shift: false,
+            alt: false,
+            control: false);
+
         private static readonly IConsoleOperations s_consoleProxy;
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1810:Initialize reference type static fields inline", Justification = "Platform specific initialization")]
@@ -100,12 +106,7 @@ internal static ConsoleKeyInfo SafeReadKey(bool intercept, CancellationToken can
             }
             catch (OperationCanceledException)
             {
-                return new ConsoleKeyInfo(
-                    keyChar: ' ',
-                    ConsoleKey.DownArrow,
-                    shift: false,
-                    alt: false,
-                    control: false);
+                return s_nullKeyInfo;
             }
         }
     }

src/PowerShellEditorServices/Services/PowerShell/Console/LegacyReadLine.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility;
 using System.Collections.Generic;

src/PowerShellEditorServices/Services/PowerShell/Console/UnixConsoleOperations.cs

@@ -2,8 +2,12 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Runtime.InteropServices;
+using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Utility;
+using Microsoft.Win32.SafeHandles;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
 {
@@ -29,34 +33,44 @@ internal class UnixConsoleOperations : IConsoleOperations
         /// </summary>
         internal UnixConsoleOperations() => WaitForKeyAvailable = LongWaitForKey;
 
-        public ConsoleKeyInfo ReadKey(bool intercept, CancellationToken cancellationToken)
-        {
-            s_readKeyHandle.Wait(cancellationToken);
+        [DllImport("libc", SetLastError = true)]
+        private static extern unsafe int write(int fd, byte* buffer, int bufferSize);
 
-            // On Unix platforms System.Console.ReadKey has an internal lock on stdin.  Because
-            // of this, if a ReadKey call is pending in one thread and in another thread
-            // Console.CursorLeft is called, both threads block until a key is pressed.
-            try
-            {
-                // The WaitForKeyAvailable delegate switches between a long delay between waits and
-                // a short timeout depending on how recently a key has been pressed. This allows us
-                // to let the CPU enter low power mode without compromising responsiveness.
-                while (!WaitForKeyAvailable(cancellationToken)) { }
-            }
-            finally
+        private static unsafe int KillReadKey()
+        {
+            byte[] buffer = new byte[] { 0 }; //Encoding.ASCII.GetBytes("\n");
+            fixed (byte* p = buffer)
             {
-                s_readKeyHandle.Release();
+                return write(0, p, buffer.Length);
             }
+        }
 
+        public ConsoleKeyInfo ReadKey(bool intercept, CancellationToken cancellationToken)
+        {
             // A key has been pressed, so acquire a lock on our internal stdin handle. This is done
             // so any of our calls to cursor position API's do not release ReadKey.
             s_stdInHandle.Wait(cancellationToken);
+            s_readKeyHandle.Wait(cancellationToken);
             try
             {
-                return System.Console.ReadKey(intercept);
+                Task<ConsoleKeyInfo> keyTask = Task.Run(() => System.Console.ReadKey(intercept));
+                keyTask.Wait(cancellationToken);
+                return keyTask.Result;
+            }
+            catch (OperationCanceledException)
+            {
+                // TODO: Write a null byte to stdin.
+                // Stream inputStream = System.Console.OpenStandardInput();
+                // inputStream.Write(new byte[] { 0 }, 0, 1);
+                // Interop.Sys.FileDescriptors.STDIN_FILENO
+                // SafeFileHandle stdinHandle = new((IntPtr)0, false);
+                // ConsoleStream stdinStream = new(stdinHandle, FileAccess.Write);
+                KillReadKey();
+                return ConsoleProxy.s_nullKeyInfo;
             }
             finally
             {
+                s_readKeyHandle.Release();
                 s_stdInHandle.Release();
             }
         }

src/PowerShellEditorServices/Services/PowerShell/Host/PsesInternalHost.cs

@@ -868,8 +868,7 @@ private ConsoleKeyInfo ReadKey(bool intercept)
             // So instead we keep track of the last key here.
             // This isn't functionally required,
             // but helps us determine when the prompt needs a newline added
-
-            _lastKey = ConsoleProxy.SafeReadKey(intercept, CancellationToken.None);
+            _lastKey = ConsoleProxy.SafeReadKey(intercept, _cancellationContext.Peek().CancellationToken);
             return _lastKey.Value;
         }
 

src/PowerShellEditorServices/Services/PowerShell/Utility/CancellationContext.cs

@@ -49,6 +49,8 @@ public void CancelCurrentTask()
             }
         }
 
+        public CancellationScope Peek() => _cancellationSourceStack.TryPeek(out CancellationScope currentCancellationSource) ? currentCancellationSource : null;
+
         public void CancelCurrentTaskStack()
         {
             foreach (CancellationScope scope in _cancellationSourceStack)