diff --git a/src/core/Microsoft.Dynamic/Ast/AsyncDebugSupport.cs b/src/core/Microsoft.Dynamic/Ast/AsyncDebugSupport.cs
new file mode 100644
index 00000000..396583c8
--- /dev/null
+++ b/src/core/Microsoft.Dynamic/Ast/AsyncDebugSupport.cs
@@ -0,0 +1,213 @@
+// 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.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+using Microsoft.Scripting.Debugging;
+using Microsoft.Scripting.Debugging.CompilerServices;
+
+namespace Microsoft.Scripting.Ast {
+ ///
+ /// Compiles an async body for tracing.
+ ///
+ ///
+ /// Used by and AsyncEnumerableRewriter when the async node carries a debug hook (set by the host
+ /// only when it builds the tracing variant of the code, e.g. when sys.settrace is active). In two steps:
+ ///
+ /// instruments the body before it is sliced into a state machine, so that the debug points
+ /// end up in the same state machine as the awaits and yields.
+ /// wraps the resulting state machine in a , which dispatches
+ /// the trace events while the driver pumps it.
+ ///
+ ///
+ /// The body's locals are not lifted, so its frame reports its location but no locals; the scope map is therefore uniform
+ /// (every sequence point maps to no locals).
+ ///
+ internal sealed class AsyncDebugSupport {
+ private static readonly ConstructorInfo s_tracingStateMachineCtor
+ = typeof(TracingStateMachine).GetConstructor(
+ BindingFlags.Instance | BindingFlags.NonPublic, binder: null,
+ [typeof(IEnumerator), typeof(DebugContext), typeof(FunctionInfo), typeof(StrongBox), typeof(StrongBox), typeof(bool)],
+ modifiers: null)!;
+ private static readonly MethodInfo s_onExceptionCaughtMethod
+ = typeof(TracingStateMachine).GetMethod(nameof(TracingStateMachine.OnExceptionCaught), BindingFlags.Instance | BindingFlags.NonPublic)!;
+
+ private readonly DebugContext _debugContext;
+ private readonly DebugLambdaInfo _lambdaInfo;
+ private readonly string? _name;
+ private readonly ParameterExpression _exceptionSlot;
+
+ // Holds the TracingStateMachine, so that the body's exception handlers can report to it.
+ private readonly ParameterExpression _tracer = Expression.Variable(typeof(TracingStateMachine), "$tracer");
+
+ // Null until the body is instrumented, and also if it has no sequence points (then there is nothing to trace).
+ private FunctionInfo? _functionInfo;
+
+ /// The body's exception slot, which the body rethrows from at each resume point.
+ internal AsyncDebugSupport(DebugContext debugContext, DebugLambdaInfo lambdaInfo, string? name, ParameterExpression exceptionSlot) {
+ _debugContext = debugContext;
+ _lambdaInfo = lambdaInfo;
+ _name = name;
+ _exceptionSlot = exceptionSlot;
+ }
+
+
+ ///
+ /// Instruments to report its sequence points and the exceptions it handles.
+ ///
+ ///
+ /// Each becomes { yield DebugPoint(cookie); rethrow-if-pending } on
+ /// , the label the body's awaits and yields are sliced on, and each exception handler first reports
+ /// the exception it handles. The rethrow lets an exception raised by the trace callback surface inside the body.
+ ///
+ internal Expression InjectDebugPoints(Expression body, LabelTarget yieldLabel) {
+ var injector = new DebugPointInjector(_debugContext, yieldLabel, _exceptionSlot, _tracer);
+ Expression instrumentedBody = injector.Visit(body);
+ if (injector.SequencePoints.Length == 0) {
+ return body;
+ }
+
+ _functionInfo = DebugContext.CreateFunctionInfo(
+ generatorFactory: null, // the frame cannot be remapped to a generator, so it cannot change its location either
+ _name ?? "",
+ injector.SequencePoints,
+ injector.VariableScopeMap,
+ Array.Empty(),
+ _lambdaInfo.CustomPayload);
+ return instrumentedBody;
+ }
+
+
+ ///
+ /// Wraps , the state machine of the instrumented body, in a .
+ ///
+ /// Where the body leaves its return value, or null if it has none.
+ /// Whether the state machine is driven by AsyncHelpers.DriveAsyncEnumerable.
+ internal Expression TraceStateMachine(Expression stateMachine, ParameterExpression? resultSlot, bool isAsyncEnumerable) {
+ if (_functionInfo is null) {
+ return stateMachine;
+ }
+
+ return Expression.Block(
+ typeof(TracingStateMachine),
+ [_tracer],
+ Expression.Assign(
+ _tracer,
+ Expression.New(
+ s_tracingStateMachineCtor,
+ stateMachine,
+ Expression.Constant(_debugContext),
+ Expression.Constant(_functionInfo),
+ (Expression?)resultSlot ?? Expression.Constant(null, typeof(StrongBox)),
+ _exceptionSlot,
+ Expression.Constant(isAsyncEnumerable))));
+ }
+
+
+ ///
+ /// Rewrites the debug info and the exception handlers of an async body for .
+ ///
+ ///
+ /// Each becomes a yield of a on the body's own yield label, recording
+ /// the source span per cookie, and each catch block first reports the exception to the tracer. This mirrors what
+ /// DebugInfoRewriter does to a synchronous body.
+ ///
+ private sealed class DebugPointInjector : ExpressionVisitor {
+ private readonly DebugContext _debugContext;
+ private readonly LabelTarget _yieldLabel;
+ private readonly ParameterExpression _exceptionSlot;
+ private readonly ParameterExpression _tracer;
+ private readonly List _spans = new();
+
+ internal DebugPointInjector(DebugContext debugContext, LabelTarget yieldLabel, ParameterExpression exceptionSlot, ParameterExpression tracer) {
+ _debugContext = debugContext;
+ _yieldLabel = yieldLabel;
+ _exceptionSlot = exceptionSlot;
+ _tracer = tracer;
+ }
+
+ internal DebugSourceSpan[] SequencePoints => _spans.ToArray();
+
+ internal IList[] VariableScopeMap {
+ get {
+ var map = new IList[_spans.Count];
+ for (int i = 0; i < map.Length; i++) {
+ map[i] = Array.Empty();
+ }
+ return map;
+ }
+ }
+
+ protected override Expression VisitDebugInfo(DebugInfoExpression node) {
+ if (node.IsClear) {
+ return Expression.Empty();
+ }
+
+ if (node.Document is null) {
+ throw new InvalidOperationException(
+ string.Format(CultureInfo.CurrentCulture, "DebugInfoExpression at sequence point {0} has no SymbolDocumentInfo", _spans.Count));
+ }
+
+ DebugSourceFile sourceFile = _debugContext.GetDebugSourceFile(
+ string.IsNullOrEmpty(node.Document.FileName) ? "" : node.Document.FileName);
+
+ int cookie = _spans.Count;
+ _spans.Add(new DebugSourceSpan(sourceFile, node.StartLine, node.StartColumn, node.EndLine, node.EndColumn));
+
+ return Expression.Block(
+ typeof(void),
+ Utils.YieldReturn(_yieldLabel, Expression.Constant(new DebugPoint(cookie))),
+ AsyncRewriter.RethrowIfPending(_exceptionSlot));
+ }
+
+ protected override Expression VisitTry(TryExpression node) {
+ var visited = (TryExpression)base.VisitTry(node);
+ if (visited.Handlers.Count == 0) {
+ return visited;
+ }
+
+ var handlers = new List(visited.Handlers.Count);
+ foreach (CatchBlock handler in visited.Handlers) {
+ ParameterExpression variable = handler.Variable ?? Expression.Variable(handler.Test, null);
+ Expression exception = variable.Type == typeof(Exception) ? variable : Expression.Convert(variable, typeof(Exception));
+ handlers.Add(Expression.MakeCatchBlock(
+ handler.Test,
+ variable,
+ Expression.Block(Expression.Call(_tracer, s_onExceptionCaughtMethod, exception), handler.Body),
+ handler.Filter));
+ }
+ return Expression.MakeTry(visited.Type, visited.Body, visited.Finally, visited.Fault, handlers);
+ }
+
+ protected override Expression VisitLambda(Expression node) {
+ // Don't descend into nested lambdas — they have their own debug context.
+ return node;
+ }
+
+ protected override Expression VisitExtension(Expression node) {
+ // A nested async node is sliced into its own state machine against its own label; leave it opaque.
+ if (node is AsyncExpression or GeneratorExpression
+#if NET
+ or AsyncEnumerableExpression
+#endif
+ ) {
+ return node;
+ }
+ if (node is YieldExpression { Value: not null } yield && yield.Target == _yieldLabel) {
+ return Expression.Block(
+ base.VisitExtension(node),
+ AsyncRewriter.RethrowIfPending(_exceptionSlot));
+ }
+ return base.VisitExtension(node);
+ }
+ }
+ }
+}
diff --git a/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableExpression.cs b/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableExpression.cs
index 6c2377cf..fd5b60e7 100644
--- a/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableExpression.cs
+++ b/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableExpression.cs
@@ -13,6 +13,7 @@
using System.Threading;
using System.Threading.Tasks;
+using Microsoft.Scripting.Debugging.CompilerServices;
using Microsoft.Scripting.Utils;
namespace Microsoft.Scripting.Ast {
@@ -35,12 +36,33 @@ public sealed class AsyncEnumerableExpression : Expression {
internal AsyncEnumerableExpression(string? name, Expression body, LabelTarget yieldLabel,
Expression? cancellationToken = null,
- Expression? cancellationException = null) {
+ Expression? cancellationException = null,
+ DebugContext? debugContext = null,
+ DebugLambdaInfo? debugLambdaInfo = null) {
Name = name;
Body = body;
YieldLabel = yieldLabel;
CancellationToken = cancellationToken ?? Utils.DefaultCancellationToken;
CancellationException = cancellationException ?? Utils.DefaultCancellationException;
+ DebugContext = debugContext;
+ DebugLambdaInfo = debugLambdaInfo;
+ }
+
+ ///
+ /// Optional tracing hook; see . When both are non-null,
+ /// instruments the body with debug points so it becomes traceable.
+ ///
+ internal DebugContext? DebugContext { get; }
+
+ internal DebugLambdaInfo? DebugLambdaInfo { get; }
+
+ ///
+ /// Returns a copy of this node that instruments its body for tracing under the given debug context.
+ ///
+ public AsyncEnumerableExpression WithDebugInfo(DebugContext debugContext, DebugLambdaInfo debugLambdaInfo) {
+ ContractUtils.RequiresNotNull(debugContext, nameof(debugContext));
+ ContractUtils.RequiresNotNull(debugLambdaInfo, nameof(debugLambdaInfo));
+ return new AsyncEnumerableExpression(Name, Body, YieldLabel, CancellationToken, CancellationException, debugContext, debugLambdaInfo);
}
/// Optional diagnostic name (forwarded to the inner generator).
@@ -76,7 +98,7 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) {
Expression ct = visitor.Visit(CancellationToken);
Expression ce = visitor.Visit(CancellationException);
if (b == Body && ct == CancellationToken && ce == CancellationException) return this;
- return new AsyncEnumerableExpression(Name, b, YieldLabel, ct, ce);
+ return new AsyncEnumerableExpression(Name, b, YieldLabel, ct, ce, DebugContext, DebugLambdaInfo);
}
}
diff --git a/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableRewriter.cs b/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableRewriter.cs
index 14a78e50..27a3e012 100644
--- a/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableRewriter.cs
+++ b/src/core/Microsoft.Dynamic/Ast/AsyncEnumerableRewriter.cs
@@ -11,7 +11,6 @@
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
-using System.Runtime.ExceptionServices;
using System.Threading.Tasks;
namespace Microsoft.Scripting.Ast {
@@ -28,8 +27,6 @@ private static readonly ConstructorInfo s_awaitPointCtor
= typeof(Runtime.AwaitPoint).GetConstructor([typeof(Task)])!;
private static readonly FieldInfo s_valueSlotField
= typeof(StrongBox).GetField(nameof(StrongBox.Value))!;
- private static readonly FieldInfo s_exceptionSlotField
- = typeof(StrongBox).GetField(nameof(StrongBox.Value))!;
private static readonly ConstructorInfo s_valueSlotCtor
= typeof(StrongBox).GetConstructor(Type.EmptyTypes)!;
private static readonly ConstructorInfo s_exceptionSlotCtor
@@ -48,8 +45,17 @@ public Expression Reduce() {
ParameterExpression valueSlot = Expression.Variable(typeof(StrongBox), "$asyncValue");
ParameterExpression exceptionSlot = Expression.Variable(typeof(StrongBox), "$awaitException");
+ // Optional tracing, as in AsyncRewriter: the debug points are injected on the same label the body's yields and awaits target,
+ // so they all land in one state machine, which is then wrapped in a TracingStateMachine.
+ Expression body = _node.Body;
+ AsyncDebugSupport? debugSupport = null;
+ if (_node.DebugContext is not null && _node.DebugLambdaInfo is not null) {
+ debugSupport = new AsyncDebugSupport(_node.DebugContext, _node.DebugLambdaInfo, _node.Name, exceptionSlot);
+ body = debugSupport.InjectDebugPoints(body, _node.YieldLabel);
+ }
+
var rewriter = new AwaitToAwaitPointRewriter(_node.YieldLabel, valueSlot, exceptionSlot);
- Expression rewrittenBody = rewriter.Visit(_node.Body);
+ Expression rewrittenBody = rewriter.Visit(body);
// Coerce to void for Utils.Generator (the generator body's value is discarded).
Expression generatorBody = rewrittenBody.Type == typeof(void)
@@ -62,12 +68,13 @@ public Expression Reduce() {
generatorBody,
typeof(IEnumerator