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)); }