Create async coroutine cold

BCSharp · BCSharp · commit 22e8f43ac1c9 · 2026-05-28T14:26:58.000-07:00
diff --git a/src/core/IronPython/Compiler/Ast/AstMethods.cs b/src/core/IronPython/Compiler/Ast/AstMethods.cs
@@ -82,7 +82,7 @@ internal static class AstMethods {
         public static readonly MethodInfo MakeCoroutine = GetMethod((Func<PythonFunction, MutableTuple, object, PythonCoroutine>)PythonOps.MakeCoroutine);
 #if FEATURE_NET_ASYNC
         public static readonly MethodInfo AsTaskForAwait = GetMethod((Func<object, System.Threading.Tasks.Task<object>>)PythonOps.AsTaskForAwait);
-        public static readonly MethodInfo MakeAsyncCoroutine = GetMethod((Func<PythonFunction, System.Threading.Tasks.Task<object>, System.Threading.CancellationTokenSource, System.Runtime.CompilerServices.StrongBox<System.Exception>, PythonCoroutine>)PythonOps.MakeAsyncCoroutine);
+        public static readonly MethodInfo MakeAsyncCoroutine = GetMethod((Func<PythonFunction, Func<System.Threading.Tasks.Task<object>>, System.Threading.CancellationTokenSource, System.Runtime.CompilerServices.StrongBox<System.Exception>, PythonCoroutine>)PythonOps.MakeAsyncCoroutine);
         public static readonly MethodInfo MakeAsyncGenerator = GetMethod((Func<PythonFunction, System.Collections.Generic.IAsyncEnumerable<object>, System.Runtime.CompilerServices.StrongBox<object>, System.Runtime.CompilerServices.StrongBox<System.Exception>, System.Threading.CancellationTokenSource, PythonAsyncGenerator>)PythonOps.MakeAsyncGenerator);
 #endif
 
diff --git a/src/core/IronPython/Compiler/Ast/FunctionDefinition.cs b/src/core/IronPython/Compiler/Ast/FunctionDefinition.cs
@@ -760,14 +760,20 @@ private LightLambdaExpression CreateFunctionLambda() {
                             cts));
                 } else {
                     // Plain async def: the body returns a PythonCoroutine wrapping a Task<object?>.
+                    // Lazy start: hand MakeAsyncCoroutine a thunk (Func<Task<object?>>) instead of an
+                    // already-running Task, so the body doesn't execute until the coroutine is first driven
+                    // (send/AsTask). This makes calling an async def side-effect-free (PEP 492) and lets the
+                    // body's first await capture the driver's SynchronizationContext rather than whatever
+                    // context happened to be current at construction.
                     body = MSAst.Expression.Block(
                         new[] { cts, excBox },
                         MSAst.Expression.Assign(cts, MSAst.Expression.New(typeof(System.Threading.CancellationTokenSource))),
                         MSAst.Expression.Assign(excBox, MSAst.Expression.New(typeof(System.Runtime.CompilerServices.StrongBox<Exception>))),
                         Ast.Call(
                             AstMethods.MakeAsyncCoroutine,
                             _functionParam,
-                            AstUtils.Async(Name, body, ctToken, excBox),
+                            MSAst.Expression.Lambda<Func<System.Threading.Tasks.Task<object>>>(
+                                AstUtils.Async(Name, body, ctToken, excBox)),
                             cts,
                             excBox));
                 }
diff --git a/src/core/IronPython/Runtime/Coroutine.cs b/src/core/IronPython/Runtime/Coroutine.cs
@@ -31,23 +31,34 @@ public sealed class PythonCoroutine : ICodeFormattable, IWeakReferenceable {
         //                            at cancellation time, that exception is surfaced
         //                            to the body instead of OperationCanceledException.
         //                            throw(non-OCE) writes here before cancelling.
-        private readonly Task<object?> _task;
+        //
+        // Lazy start: the body is not executed at construction. _factory is the thunk
+        // that creates (and thereby starts driving) the Task on first access; _task
+        // caches the materialized Task. Calling an async def is therefore side-effect
+        // free until the coroutine is first driven (send/AsTask/GetAwaiter) — PEP 492.
+        private readonly Func<Task<object?>> _factory;
+        private Task<object?>? _task;
         private readonly string _name;
         private readonly FunctionCode? _code;
         private readonly CancellationTokenSource _cts;
         private readonly StrongBox<Exception?> _cancellationException;
         private WeakRefTracker? _tracker;
 
-        internal PythonCoroutine(Task<object?> task, string name, FunctionCode? code,
+        internal PythonCoroutine(Func<Task<object?>> factory, string name, FunctionCode? code,
                                   CancellationTokenSource cts,
                                   StrongBox<Exception?> cancellationException) {
-            _task = task;
+            _factory = factory;
             _name = name;
             _code = code;
             _cts = cts;
             _cancellationException = cancellationException;
         }
 
+        /// <summary>
+        /// Materialize (and start) the underlying Task on first access, caching it thereafter.
+        /// </summary>
+        private Task<object?> EnsureTask() => _task ??= _factory();
+
         [LightThrowing]
         public object send(object? value) {
             // Fast path: task already completed. Dispatch on terminal state without
@@ -58,18 +69,20 @@ public object send(object? value) {
             // not pay for exception unwinding (GetAwaiter().GetResult() would observe
             // and rethrow cancel/fault). After waiting, the same terminal-state
             // dispatch below applies.
-            if (!_task.IsCompleted) {
-                ((IAsyncResult)_task).AsyncWaitHandle.WaitOne();
+            var task = EnsureTask();
+            if (!task.IsCompleted) {
+                // TODO: coroutines should be steppable via send(), one await at a time.
+                ((IAsyncResult)task).AsyncWaitHandle.WaitOne();
             }
-            if (_task.IsCanceled) {
+            if (task.IsCanceled) {
                 // Surfaces as Python CancelledError via the OCE -> CancelledError mapping in PythonExceptions.
                 // We need an OperationCanceledException instance because the Canceled task carries no Exception object.
-                return LightExceptions.Throw(new TaskCanceledException(_task));
+                return LightExceptions.Throw(new TaskCanceledException(task));
             }
-            if (_task.IsFaulted) {
-                return LightExceptions.Throw(_task.Exception?.InnerException ?? _task.Exception);
+            if (task.IsFaulted) {
+                return LightExceptions.Throw(task.Exception?.InnerException ?? task.Exception);
             }
-            return LightExceptions.Throw(new PythonExceptions._StopIteration().InitAndGetClrException(_task.Result!));
+            return LightExceptions.Throw(new PythonExceptions._StopIteration().InitAndGetClrException(task.Result!));
         }
 
         [LightThrowing]
@@ -99,7 +112,8 @@ public object @throw(object? type, object? value, object? traceback) {
             Exception ex = PythonOps.MakeExceptionForGenerator(
                 DefaultContext.Default, type, value, traceback, cause: null);
 
-            if (_task.IsCompleted) {
+            var task = EnsureTask();
+            if (task.IsCompleted) {
                 // Regime 1: coroutine has finished. throw() raises the exception immediately —
                 // the body has nothing left to observe it. Matches CPython.
                 return LightExceptions.Throw(ex);
@@ -115,18 +129,19 @@ public object @throw(object? type, object? value, object? traceback) {
             // Wait for the body to settle. After this the task is in a terminal state — dispatch via
             // the same logic as send() so the body's reaction (catch-and-return, propagate, etc.) is
             // reflected back to the caller of throw().
-            ((IAsyncResult)_task).AsyncWaitHandle.WaitOne();
+            ((IAsyncResult)task).AsyncWaitHandle.WaitOne();
             return SettleCompletedTask();
         }
 
         private object SettleCompletedTask() {
-            if (_task.IsCanceled) {
-                return LightExceptions.Throw(new TaskCanceledException(_task));
+            var task = EnsureTask();
+            if (task.IsCanceled) {
+                return LightExceptions.Throw(new TaskCanceledException(task));
             }
-            if (_task.IsFaulted) {
-                return LightExceptions.Throw(_task.Exception?.InnerException ?? _task.Exception);
+            if (task.IsFaulted) {
+                return LightExceptions.Throw(task.Exception?.InnerException ?? task.Exception);
             }
-            return LightExceptions.Throw(new PythonExceptions._StopIteration().InitAndGetClrException(_task.Result!));
+            return LightExceptions.Throw(new PythonExceptions._StopIteration().InitAndGetClrException(task.Result!));
         }
 
         [LightThrowing]
@@ -136,21 +151,23 @@ private object SettleCompletedTask() {
 
         public FunctionCode? cr_code => _code;
 
-        public int cr_running => _task.IsCompleted ? 0 : 1;
+        // A not-yet-driven coroutine reports 0 (not running) without materializing the
+        // Task — merely inspecting cr_running must not start the body.
+        public int cr_running => _task is null || _task.IsCompleted ? 0 : 1;
 
         public TraceBackFrame? cr_frame => null;
 
         public string __name__ => _name;
 
         public string __qualname__ => _name;
 
-        /// <summary>Returns the underlying <see cref="Task{Object}"/>.</summary>
-        public Task<object?> AsTask() => _task;
+        /// <summary>Returns the underlying <see cref="Task{Object}"/>, starting the body on first call.</summary>
+        public Task<object?> AsTask() => EnsureTask();
 
         /// <summary>Enables <c>await coroutine</c> from C# code.</summary>
-        public TaskAwaiter<object?> GetAwaiter() => _task.GetAwaiter();
+        public TaskAwaiter<object?> GetAwaiter() => EnsureTask().GetAwaiter();
 
-        internal Task<object?> Task => _task;
+        internal Task<object?> Task => EnsureTask();
 #else
     [PythonType("coroutine")]
     [DontMapIDisposableToContextManager, DontMapIEnumerableToContains]
diff --git a/src/core/IronPython/Runtime/Operations/PythonOps.cs b/src/core/IronPython/Runtime/Operations/PythonOps.cs
@@ -3312,19 +3312,21 @@ public static object MakeCoroutineWrapper(PythonGenerator generator) {
         }
 
         /// <summary>
-        /// Wraps a runtime-async function's <see cref="System.Threading.Tasks.Task"/>
-        /// in a <see cref="PythonCoroutine"/> for the caller of <c>async def</c>.
+        /// Wraps a runtime-async function's deferred <see cref="System.Threading.Tasks.Task"/>
+        /// thunk in a <see cref="PythonCoroutine"/> for the caller of <c>async def</c>.
+        /// The thunk is invoked lazily on first drive (send/AsTask), so calling an
+        /// <c>async def</c> is side-effect-free until the coroutine is awaited (PEP 492).
         /// The supplied <see cref="System.Threading.CancellationTokenSource"/> and exception-override
         /// box are pre-bound to <see cref="Microsoft.Scripting.Runtime.AsyncHelpers.DriveAsync"/>'s
         /// cancellation channel — the coroutine uses them to implement <c>coro.throw(exc)</c> on a
         /// running body (set the box, cancel the CTS).
         /// </summary>
         public static PythonCoroutine MakeAsyncCoroutine(
                 PythonFunction function,
-                System.Threading.Tasks.Task<object?> task,
+                Func<System.Threading.Tasks.Task<object?>> taskFactory,
                 System.Threading.CancellationTokenSource cts,
                 System.Runtime.CompilerServices.StrongBox<System.Exception?> cancellationException) {
-            return new PythonCoroutine(task, function.__name__, function.__code__, cts, cancellationException);
+            return new PythonCoroutine(taskFactory, function.__name__, function.__code__, cts, cancellationException);
         }
 
         /// <summary>
