public override BoundStatement InstrumentYieldBreakStatement(BoundYieldBreakStatement original, BoundStatement rewritten)
{
rewritten = base.InstrumentYieldBreakStatement(original, rewritten);
if (original.WasCompilerGenerated && original.Syntax.Kind() == SyntaxKind.Block)
{
// implicit yield break added by the compiler
return(new BoundSequencePointWithSpan(original.Syntax, rewritten, ((BlockSyntax)original.Syntax).CloseBraceToken.Span));
}
return(AddSequencePoint(rewritten));
}
public override BoundNode VisitYieldBreakStatement(BoundYieldBreakStatement node)
{
Debug.Assert(_asyncIteratorInfo != null);
// Produce:
// disposeMode = true;
// goto _enclosingFinallyOrExitLabel;
return(F.Block(
// disposeMode = true;
SetDisposeMode(true),
// goto _enclosingFinallyOrExitLabel;
F.Goto(_enclosingFinallyOrExitLabel)));
}
public override BoundNode VisitYieldBreakStatement(BoundYieldBreakStatement node)
{
var result = (BoundStatement)base.VisitYieldBreakStatement(node);
// We also add sequence points for the implicit "yield break" statement at the end of the method body
// (added by FlowAnalysisPass.AppendImplicitReturn). Implicitly added "yield break" for async method
// does not need sequence points added here since it would be done later (presumably during Async rewrite).
if (this.Instrument &&
(!node.WasCompilerGenerated || (node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false)))
{
result = _instrumenter.InstrumentYieldBreakStatement(node, result);
}
return(result);
}
// insert the implicit "return" statement at the end of the method body
// Normally, we wouldn't bother attaching syntax trees to compiler-generated nodes, but these
// ones are going to have sequence points.
internal static BoundBlock AppendImplicitReturn(BoundBlock body, MethodSymbol method)
{
Debug.Assert(body != null);
Debug.Assert(method != null);
SyntaxNode syntax = body.Syntax;
Debug.Assert(body.WasCompilerGenerated ||
syntax.IsKind(SyntaxKind.Block) ||
syntax.IsKind(SyntaxKind.ArrowExpressionClause) ||
syntax.IsKind(SyntaxKind.ConstructorDeclaration));
BoundStatement ret = (method.IsIterator && !method.IsAsync)
? (BoundStatement)BoundYieldBreakStatement.Synthesized(syntax)
: BoundReturnStatement.Synthesized(syntax, RefKind.None, null);
return(body.Update(body.Locals, body.LocalFunctions, body.IsUnsafeIL, body.Statements.Add(ret)));
}
public override BoundNode VisitYieldBreakStatement(BoundYieldBreakStatement node)
{
return(GenerateReturn(finished: true));
}
public virtual BoundStatement InstrumentYieldBreakStatement(BoundYieldBreakStatement original, BoundStatement rewritten)
{
Debug.Assert(!original.WasCompilerGenerated || original.Syntax.Kind() == SyntaxKind.Block);
return(rewritten);
}
public override BoundStatement InstrumentYieldBreakStatement(BoundYieldBreakStatement original, BoundStatement rewritten)
{
return(AddDynamicAnalysis(original, base.InstrumentYieldBreakStatement(original, rewritten)));
}
public override BoundStatement InstrumentYieldBreakStatement(BoundYieldBreakStatement original, BoundStatement rewritten)
{
return(Previous.InstrumentYieldBreakStatement(original, rewritten));
}
