Add PythonCoroutine.AsTask() and GetAwaiter() for C# async interop

Allows C# code to directly await IronPython coroutines:
  object result = await coroutine;

Author: mikasoukhov

src/core/IronPython/Runtime/Coroutine.cs

@@ -4,6 +4,9 @@
 
 #nullable enable
 
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
 using Microsoft.Scripting.Runtime;
 
 using IronPython.Runtime.Exceptions;
@@ -62,6 +65,38 @@ public string __qualname__ {
             get => _generator.__name__;
         }
 
+        /// <summary>
+        /// Converts this coroutine into a .NET <see cref="Task{Object}"/>,
+        /// allowing C# code to <c>await</c> an IronPython async method.
+        /// The coroutine is driven on a single thread to avoid issues with
+        /// thread-local state in the Python generator runtime.
+        /// </summary>
+        public Task<object?> AsTask() {
+            return Task.Run(() => {
+                while (true) {
+                    object result = send(null);
+
+                    if (LightExceptions.IsLightException(result)) {
+                        var clrExc = LightExceptions.GetLightException(result);
+                        if (clrExc is StopIterationException) {
+                            var pyExc = ((IPythonAwareException)clrExc).PythonException;
+                            return pyExc is PythonExceptions._StopIteration si ? si.value : null;
+                        }
+                        throw clrExc;
+                    }
+
+                    if (result is Task task) {
+                        task.Wait();
+                    }
+                }
+            });
+        }
+
+        /// <summary>
+        /// Enables <c>await coroutine</c> from C# code.
+        /// </summary>
+        public TaskAwaiter<object?> GetAwaiter() => AsTask().GetAwaiter();
+
         internal PythonGenerator Generator => _generator;
 
         #region ICodeFormattable Members

tests/IronPython.Tests/CoroutineAsTaskTest.cs

@@ -0,0 +1,169 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information.
+
+#if NET
+
+using System;
+using System.Threading.Tasks;
+
+using IronPython.Hosting;
+using IronPython.Runtime;
+
+using Microsoft.Scripting.Hosting;
+
+using NUnit.Framework;
+
+namespace IronPythonTest {
+    public class CoroutineAsTaskTest {
+        private readonly ScriptEngine _engine;
+        private readonly ScriptScope _scope;
+
+        public CoroutineAsTaskTest() {
+            _engine = Python.CreateEngine();
+            _scope = _engine.CreateScope();
+        }
+
+        [Test]
+        public void AsTask_SimpleReturn() {
+            _engine.Execute(@"
+async def foo():
+    return 42
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = coro.AsTask().GetAwaiter().GetResult();
+            Assert.That(result, Is.EqualTo(42));
+        }
+
+        [Test]
+        public void AsTask_StringReturn() {
+            _engine.Execute(@"
+async def foo():
+    return 'hello'
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = coro.AsTask().GetAwaiter().GetResult();
+            Assert.That(result, Is.EqualTo("hello"));
+        }
+
+        [Test]
+        public void AsTask_AwaitCompletedTask() {
+            _engine.Execute(@"
+from System.Threading.Tasks import Task
+async def foo():
+    val = await Task.FromResult(10)
+    return val + 5
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = coro.AsTask().GetAwaiter().GetResult();
+            Assert.That(result, Is.EqualTo(15));
+        }
+
+        [Test]
+        public void AsTask_AwaitRealAsync() {
+            _engine.Execute(@"
+from System.Threading.Tasks import Task
+async def foo():
+    await Task.Delay(50)
+    return 'delayed'
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = coro.AsTask().GetAwaiter().GetResult();
+            Assert.That(result, Is.EqualTo("delayed"));
+        }
+
+        [Test]
+        public async Task AsTask_CanBeAwaited() {
+            _engine.Execute(@"
+from System.Threading.Tasks import Task
+async def foo():
+    await Task.Delay(50)
+    return 99
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = await coro.AsTask();
+            Assert.That(result, Is.EqualTo(99));
+        }
+
+        [Test]
+        public void AsTask_PropagatesException() {
+            _engine.Execute(@"
+async def foo():
+    raise ValueError('boom')
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            Assert.Throws<AggregateException>(() => coro.AsTask().Wait());
+        }
+
+        [Test]
+        public void AsTask_MultipleAwaits() {
+            _engine.Execute(@"
+from System.Threading.Tasks import Task
+async def foo():
+    a = await Task.FromResult(10)
+    b = await Task.FromResult(20)
+    return a + b
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = coro.AsTask().GetAwaiter().GetResult();
+            Assert.That(result, Is.EqualTo(30));
+        }
+
+        [Test]
+        public void AsTask_NoneReturn() {
+            _engine.Execute(@"
+async def foo():
+    pass
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = coro.AsTask().GetAwaiter().GetResult();
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public async Task DirectAwait_Simple() {
+            _engine.Execute(@"
+async def foo():
+    return 42
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = await coro;
+            Assert.That(result, Is.EqualTo(42));
+        }
+
+        [Test]
+        public async Task DirectAwait_WithRealAsync() {
+            _engine.Execute(@"
+from System.Threading.Tasks import Task
+async def foo():
+    await Task.Delay(50)
+    return 'done'
+coro = foo()
+", _scope);
+
+            var coro = (PythonCoroutine)_scope.GetVariable("coro");
+            var result = await coro;
+            Assert.That(result, Is.EqualTo("done"));
+        }
+    }
+}
+
+#endif