Simplify and clean up

Author: BCSharp

src/core/IronPython/Compiler/Ast/AwaitExpression.cs

@@ -14,10 +14,8 @@ namespace IronPython.Compiler.Ast {
     using Ast = MSAst.Expression;
 
     /// <summary>
-    /// Represents <c>await expr</c>. Under <c>FEATURE_NET_ASYNC</c> this compiles
-    /// directly to a DLR runtime-async suspension point. Otherwise it is
-    /// desugared into <c>yield from expr.__await__()</c> against the enclosing
-    /// generator-shaped coroutine state machine.
+    /// Represents <c>await expr</c>. Under <c>FEATURE_NET_ASYNC</c> this compiles directly to a DLR async suspension point.
+    /// Otherwise it is desugared into <c>yield from expr.__await__()</c> against the enclosing generator-shaped coroutine state machine.
     /// </summary>
     public class AwaitExpression : Expression {
 #if FEATURE_NET_ASYNC

src/core/IronPython/Compiler/Ast/FunctionDefinition.cs

@@ -8,6 +8,7 @@
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 
 using IronPython.Runtime;
 using IronPython.Runtime.Operations;
@@ -118,24 +119,21 @@ internal override int KwOnlyArgCount {
         public Expression ReturnAnnotation { get; internal set; }
 
 #if FEATURE_NET_ASYNC
-        // Under runtime-async, async functions are compiled directly to a
-        // Task<object?> via the DLR's AsyncExpression rather than reused
-        // through the generator state machine, so IsAsync no longer implies
-        // generator-shaped emission.
+        // Under .NET-async, async functions are compiled directly to a Task<object?> via the DLR's AsyncExpression
+        // rather than reused through the generator state machine, so IsAsync does not imply generator-shaped emission.
         internal override bool IsGeneratorMethod => IsGenerator;
 
-        // Async-generator (PEP 525) channels, one StrongBox per async-generator instance (per stack frame
-        // at runtime — not static). Created when lowering the async generator; declared/assigned in the
-        // function body, captured by the generator (the body's yields read them through Parent), and handed
-        // to the PythonAsyncGenerator wrapper, which writes them before each resume:
+        // Async-generator (PEP 525) channels. The StrongBox *values* are per-async-generator instance,
+        // allocated per stack frame at runtime in the function body. 
+        // Declared/assigned in the body, captured by the generator (its yields read them through Parent),
+        // and handed to the PythonAsyncGenerator wrapper, which writes them before each resume:
         //   AsyncSendSlot  — the value of `x = yield z` (asend(v); None for __anext__/async for).
         //   AsyncThrowSlot — an exception to rethrow at the yield resume point (athrow/aclose).
-        private MSAst.ParameterExpression _asyncSendSlot;
-        private MSAst.ParameterExpression _asyncThrowSlot;
-        internal MSAst.ParameterExpression AsyncSendSlot
-            => _asyncSendSlot ??= MSAst.Expression.Variable(typeof(System.Runtime.CompilerServices.StrongBox<object>), "$asyncSend");
-        internal MSAst.ParameterExpression AsyncThrowSlot
-            => _asyncThrowSlot ??= MSAst.Expression.Variable(typeof(System.Runtime.CompilerServices.StrongBox<Exception>), "$asyncThrow");
+        private readonly MSAst.ParameterExpression _asyncSendSlot = MSAst.Expression.Variable(typeof(StrongBox<object>), "$asyncSend");
+        private readonly MSAst.ParameterExpression _asyncThrowSlot = MSAst.Expression.Variable(typeof(StrongBox<Exception>), "$asyncThrow");
+
+        internal MSAst.ParameterExpression AsyncSendSlot => _asyncSendSlot;
+        internal MSAst.ParameterExpression AsyncThrowSlot => _asyncThrowSlot;
 #else
         internal override bool IsGeneratorMethod => IsGenerator || IsAsync;
 #endif
@@ -385,16 +383,14 @@ internal MSAst.Expression MakeFunctionExpression() {
                             )
                         ),
 #if FEATURE_NET_ASYNC
-                    // Async generators are lowered via AsyncEnumerableExpression in the body, so they must not
-                    // be wrapped as a PythonGenerator here — only plain (non-async) generators are.
+                    // Async generators are lowered via AsyncEnumerableExpression in the body,
+                    // so they must not be wrapped as a PythonGenerator here — only plain (non-async) generators are.
                     (IsGenerator && !IsAsync) ?
-                        (MSAst.Expression)new PythonGeneratorExpression(code, GlobalParent.PyContext.Options.CompilationThreshold, IsAsync) :
-                        (MSAst.Expression)code
 #else
                     (IsGenerator || IsAsync) ?
+#endif
                         (MSAst.Expression)new PythonGeneratorExpression(code, GlobalParent.PyContext.Options.CompilationThreshold, IsAsync) :
                         (MSAst.Expression)code
-#endif
                 );
             } else {
                 ret = Ast.Call(
@@ -695,18 +691,15 @@ private LightLambdaExpression CreateFunctionLambda() {
             // The exception traceback needs to come from the generator's method body, and so we must do the check and throw
             // from inside the generator.
 #if FEATURE_NET_ASYNC
-            // Async generators have no backing PythonGenerator (they lower to IAsyncEnumerable via
-            // AsyncEnumerableExpression), so skip the $generator.CheckThrowable() prologue for them.
+            // Async generators have no backing PythonGenerator (they lower to IAsyncEnumerable via AsyncEnumerableExpression),
+            // so skip the $generator.CheckThrowable() prologue for them.
             if (IsGenerator && !IsAsync) {
-                MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
-                statements.Add(s1);
-            }
 #else
             if (IsGenerator || IsAsync) {
+#endif
                 MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
                 statements.Add(s1);
             }
-#endif
 
             if (Body.CanThrow && !(Body is SuiteStatement) && Body.StartIndex != -1) {
                 statements.Add(UpdateLineNumber(GlobalParent.IndexToLocation(Body.StartIndex).Line));
@@ -726,16 +719,15 @@ private LightLambdaExpression CreateFunctionLambda() {
             body = AddReturnTarget(body);
 
 #if FEATURE_NET_ASYNC
-            // Under runtime-async, an `async def` body returns a PythonCoroutine wrapping a
-            // Task<object?>. We pre-allocate a CancellationTokenSource and a StrongBox<Exception?>
-            // here so the same instances are shared with both AsyncExpression (which threads them into
-            // AsyncHelpers.DriveAsync) and PythonCoroutine (which uses them to implement
-            // coro.throw(exc) on a running coroutine: write the exception to the box, cancel the CTS,
-            // and DriveAsync surfaces that exception in place of OperationCanceledException).
+            // Under .NET-async, an `async def` body returns a PythonCoroutine wrapping a Task<object?>.
+            // We pre-allocate a CancellationTokenSource and a StrongBox<Exception?> here
+            // so the same instances are shared with both AsyncExpression, which threads them into AsyncHelpers.DriveAsync
+            // and PythonCoroutine, which uses them to implement coro.throw(exc) on a running coroutine:
+            // write the exception to the box, cancel the CTS, and DriveAsync surfaces that exception in place of OperationCanceledException.
             if (IsAsync) {
-                var cts = MSAst.Expression.Variable(typeof(System.Threading.CancellationTokenSource), "$cts");
-                var excBox = MSAst.Expression.Variable(typeof(System.Runtime.CompilerServices.StrongBox<Exception>), "$cancelExc");
-                var ctToken = MSAst.Expression.Property(cts, nameof(System.Threading.CancellationTokenSource.Token));
+                var cts = MSAst.Expression.Variable(typeof(CancellationTokenSource), "$cts");
+                var excBox = MSAst.Expression.Variable(typeof(StrongBox<Exception>), "$cancelExc");
+                var ctToken = MSAst.Expression.Property(cts, nameof(CancellationTokenSource.Token));
                 if (IsGenerator) {
                     // Async generator: the body has both `await` and `yield`. Lower it to an
                     // IAsyncEnumerable<object?> via AsyncEnumerableExpression, sharing the generator label so
@@ -746,11 +738,11 @@ private LightLambdaExpression CreateFunctionLambda() {
                     var sendSlot = AsyncSendSlot;
                     var throwSlot = AsyncThrowSlot;
                     body = MSAst.Expression.Block(
-                        new[] { cts, excBox, sendSlot, throwSlot },
-                        MSAst.Expression.Assign(cts, MSAst.Expression.New(typeof(System.Threading.CancellationTokenSource))),
-                        MSAst.Expression.Assign(excBox, MSAst.Expression.New(typeof(System.Runtime.CompilerServices.StrongBox<Exception>))),
-                        MSAst.Expression.Assign(sendSlot, MSAst.Expression.New(typeof(System.Runtime.CompilerServices.StrongBox<object>))),
-                        MSAst.Expression.Assign(throwSlot, MSAst.Expression.New(typeof(System.Runtime.CompilerServices.StrongBox<Exception>))),
+                        [cts, excBox, sendSlot, throwSlot],
+                        MSAst.Expression.Assign(cts, MSAst.Expression.New(typeof(CancellationTokenSource))),
+                        MSAst.Expression.Assign(excBox, MSAst.Expression.New(typeof(StrongBox<Exception>))),
+                        MSAst.Expression.Assign(sendSlot, MSAst.Expression.New(typeof(StrongBox<object>))),
+                        MSAst.Expression.Assign(throwSlot, MSAst.Expression.New(typeof(StrongBox<Exception>))),
                         Ast.Call(
                             AstMethods.MakeAsyncGenerator,
                             _functionParam,
@@ -760,19 +752,18 @@ 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.
+                    // 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>))),
+                        [cts, excBox],
+                        MSAst.Expression.Assign(cts, MSAst.Expression.New(typeof(CancellationTokenSource))),
+                        MSAst.Expression.Assign(excBox, MSAst.Expression.New(typeof(StrongBox<Exception>))),
                         Ast.Call(
                             AstMethods.MakeAsyncCoroutine,
                             _functionParam,
-                            MSAst.Expression.Lambda<Func<System.Threading.Tasks.Task<object>>>(
+                            MSAst.Expression.Lambda<Func<Task<object>>>(
                                 AstUtils.Async(Name, body, ctToken, excBox)),
                             cts,
                             excBox));

src/core/IronPython/Compiler/Ast/ReturnStatement.cs

@@ -2,6 +2,8 @@
 // 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.
 
+using System.Diagnostics;
+
 using MSAst = System.Linq.Expressions;
 
 namespace IronPython.Compiler.Ast {
@@ -18,11 +20,12 @@ public ReturnStatement(Expression expression) {
         public override MSAst.Expression Reduce() {
             if (Parent.IsGeneratorMethod) {
 #if FEATURE_NET_ASYNC
-                // An async generator (`async def` with `yield`) lowers through the DLR generator via
-                // AsyncEnumerableExpression, which doesn't understand IronPython's -2 "generator-return"
-                // marker. `return` there is always bare (`return value` is a SyntaxError in async
-                // generators) and simply ends the async iteration — map it to a YieldBreak.
+                // An async generator (`async def` with `yield`) lowers through the DLR generator via AsyncEnumerableExpression,
+                // which doesn't understand IronPython's -2 "generator-return" marker.
+                // `return` there is always bare (`return value` is a SyntaxError in async generators)
+                // and simply ends the async iteration — map it to a YieldBreak without a value.
                 if (Parent is FunctionDefinition { IsAsync: true }) {
+                    Debug.Assert(Expression == null, "async generators should not have a return value");
                     return GlobalParent.AddDebugInfo(AstUtils.YieldBreak(GeneratorLabel), Span);
                 }
 #endif

src/core/IronPython/Compiler/Ast/YieldExpression.cs

@@ -7,6 +7,8 @@
 using MSAst = System.Linq.Expressions;
 
 using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Diagnostics;
 using Microsoft.Scripting;
 using Microsoft.Scripting.Runtime;
@@ -21,9 +23,9 @@ namespace IronPython.Compiler.Ast {
     public class YieldExpression : Expression {
 #if FEATURE_NET_ASYNC
         private static readonly System.Reflection.MethodInfo s_captureMethod
-            = typeof(System.Runtime.ExceptionServices.ExceptionDispatchInfo).GetMethod(nameof(System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture))!;
+            = typeof(ExceptionDispatchInfo).GetMethod(nameof(ExceptionDispatchInfo.Capture))!;
         private static readonly System.Reflection.MethodInfo s_throwMethod
-            = typeof(System.Runtime.ExceptionServices.ExceptionDispatchInfo).GetMethod(nameof(System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw), Type.EmptyTypes)!;
+            = typeof(ExceptionDispatchInfo).GetMethod(nameof(ExceptionDispatchInfo.Throw), Type.EmptyTypes)!;
 #endif
 
         public YieldExpression(Expression? expression) {
@@ -53,26 +55,26 @@ public override MSAst.Expression Reduce() {
             MSAst.Expression yieldValue = Expression == null ? AstUtils.Constant(null) : AstUtils.Convert(Expression, typeof(object));
 
 #if FEATURE_NET_ASYNC
-            // An async generator (`async def` with `yield`) is lowered via AsyncEnumerableExpression and has no
-            // backing PythonGenerator, so there is no `$generator` to call CheckThrowable() on. Instead the
-            // resume reads two per-generator cells that PythonAsyncGenerator writes before advancing:
-            //   AsyncThrowSlot — if set (athrow/aclose), rethrow it here (preserving stack); cleared first so a
-            //                    body that catches it and yields again doesn't re-throw on the next resume.
+            // An async generator (`async def` with `yield`) is lowered via AsyncEnumerableExpression
+            // and has no backing PythonGenerator, so there is no `$generator` to call CheckThrowable() on.
+            // Instead the resume reads two per-generator cells that PythonAsyncGenerator writes before advancing:
+            //   AsyncThrowSlot — if set (athrow/aclose), rethrow it here (preserving stack);
+            //                    cleared first so a body that catches it and yields again doesn't re-throw on the next resume.
             //   AsyncSendSlot  — the value of the yield expression: the asend(v) value, or None.
             if (Parent is FunctionDefinition { IsAsync: true } fd) {
                 MSAst.ParameterExpression sendSlot = fd.AsyncSendSlot;
                 MSAst.ParameterExpression throwSlot = fd.AsyncThrowSlot;
                 MSAst.ParameterExpression pending = Ast.Variable(typeof(Exception), "$athrow");
                 return Ast.Block(
                     typeof(object),
-                    new[] { pending },
+                    [pending],
                     AstUtils.YieldReturn(GeneratorLabel, yieldValue),
-                    Ast.Assign(pending, Ast.Field(throwSlot, nameof(System.Runtime.CompilerServices.StrongBox<Exception>.Value))),
-                    Ast.Assign(Ast.Field(throwSlot, nameof(System.Runtime.CompilerServices.StrongBox<Exception>.Value)), Ast.Constant(null, typeof(Exception))),
+                    Ast.Assign(pending, Ast.Field(throwSlot, nameof(StrongBox<Exception>.Value))),
+                    Ast.Assign(Ast.Field(throwSlot, nameof(StrongBox<Exception>.Value)), Ast.Constant(null, typeof(Exception))),
                     Ast.IfThen(
                         Ast.ReferenceNotEqual(pending, Ast.Constant(null, typeof(Exception))),
                         Ast.Call(Ast.Call(s_captureMethod, pending), s_throwMethod)),
-                    Ast.Field(sendSlot, nameof(System.Runtime.CompilerServices.StrongBox<object>.Value))
+                    Ast.Field(sendSlot, nameof(StrongBox<object>.Value))
                 );
             }
 #endif

src/core/IronPython/Compiler/Parser.cs

@@ -2000,11 +2000,10 @@ private Expression ParseAtomExpr() {
                     ReportSyntaxError("'await' outside async function");
                 }
 #if !FEATURE_NET_ASYNC
-                // Under the async-generator path, `await` desugars to `yield from`, so the
-                // enclosing function must be marked a generator. Under FEATURE_NET_ASYNC
-                // the body is lowered through AsyncExpression and is *not*
-                // a Python generator — leaving IsGenerator false here is what keeps
-                // ReturnStatement out of the yield branch.
+                // Under the generator-based async path, `await` desugars to `yield from`,
+                // so the enclosing function must be marked a generator.
+                // Under FEATURE_NET_ASYNC, the body is lowered through AsyncExpression and is *not* a Python generator
+                // so this mark assignment is being skipped here.
                 if (current is not null) {
                     current.IsGenerator = true;
                     current.GeneratorStop = GeneratorStop;