private void EmitSequencePointStatement(BoundSequencePoint node)
{
CSharpSyntaxNode syntax = node.Syntax;
if (_emitPdbSequencePoints)
{
if (syntax == null) //Null syntax indicates hidden sequence point (not equivalent to WasCompilerGenerated)
{
EmitHiddenSequencePoint();
}
else
{
EmitSequencePoint(syntax);
}
}
BoundStatement statement = node.StatementOpt;
int instructionsEmitted = 0;
if (statement != null)
{
instructionsEmitted = this.EmitStatementAndCountInstructions(statement);
}
if (instructionsEmitted == 0 && syntax != null && _ilEmitStyle == ILEmitStyle.Debug)
{
// if there was no code emitted, then emit nop
// otherwise this point could get associated with some random statement, possibly in a wrong scope
_builder.EmitOpCode(ILOpCode.Nop);
}
}
private void EmitSequencePointStatement(BoundSequencePoint node)
{
AssertExplicitSequencePointAllowed();
CSharpSyntaxNode syntax = node.Syntax;
if (this.emitSequencePoints)
{
if (syntax == null) //Null syntax indicates hidden sequence point (not equivalent to WasCompilerGenerated)
{
EmitHiddenSequencePoint();
}
else
{
EmitSequencePoint(syntax);
}
}
BoundStatement statement = node.StatementOpt;
int instructionsEmitted = 0;
if (statement != null)
{
instructionsEmitted = -builder.InstructionsEmitted;
this.EmitStatement(statement);
instructionsEmitted += builder.InstructionsEmitted;
}
if (instructionsEmitted == 0 && syntax != null && noOptimizations)
{
// if there was no code emitted, then emit nop
// otherwise this point could get associated with some random statement, possibly in a wrong scope
builder.EmitOpCode(ILOpCode.Nop);
}
}
/// <summary>
/// Add sequence point |here|:
///
/// foreach (Type var in |expr|) { }
/// </summary>
/// <remarks>
/// Hit once, before looping begins.
/// </remarks>
private void AddForEachExpressionSequencePoint(ForEachStatementSyntax forEachSyntax, ref BoundStatement collectionVarDecl)
{
if (this.generateDebugInfo)
{
// NOTE: This is slightly different from Dev10. In Dev10, when you stop the debugger
// on the collection expression, you can see the (uninitialized) iteration variable.
// In Roslyn, you cannot because the iteration variable is re-declared in each iteration
// of the loop and is, therefore, not yet in scope.
collectionVarDecl = new BoundSequencePoint(forEachSyntax.Expression, collectionVarDecl);
}
}
private BoundStatement RewriteWhileStatement(
SyntaxNode syntax,
BoundExpression rewrittenCondition,
TextSpan conditionSequencePointSpan,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
var startLabel = new GeneratedLabelSymbol("start");
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel);
if (this.generateDebugInfo)
{
ifConditionGotoStart = new BoundSequencePointWithSpan(syntax, ifConditionGotoStart, conditionSequencePointSpan);
}
// while (condition)
// body;
//
// becomes
//
// goto continue;
// start:
// body
// continue:
// GotoIfTrue condition start;
// break:
BoundStatement gotoContinue = new BoundGotoStatement(syntax, continueLabel);
if (this.generateDebugInfo)
{
//mark the initial jump as hidden.
//We do it to tell that this is not a part of previou statement.
//This jump may be a target of another jump (for example if loops are nested) and that will make
//impression of the previous statement being re-executed
gotoContinue = new BoundSequencePoint(null, gotoContinue);
}
return(BoundStatementList.Synthesized(syntax, hasErrors,
gotoContinue,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, continueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, breakLabel)));
}
private void EmitSequencePointStatement(BoundSequencePoint node)
{
CSharpSyntaxNode syntax = node.Syntax;
if (_emitPdbSequencePoints)
{
if (syntax == null) //Null syntax indicates hidden sequence point (not equivalent to WasCompilerGenerated)
{
EmitHiddenSequencePoint();
}
else
{
EmitSequencePoint(syntax);
}
}
BoundStatement statement = node.StatementOpt;
int instructionsEmitted = 0;
if (statement != null)
{
instructionsEmitted = this.EmitStatementAndCountInstructions(statement);
}
if (instructionsEmitted == 0 && syntax != null && _ilEmitStyle == ILEmitStyle.Debug)
{
// if there was no code emitted, then emit nop
// otherwise this point could get associated with some random statement, possibly in a wrong scope
_builder.EmitOpCode(ILOpCode.Nop);
}
}
private void EmitSequencePointStatement(BoundSequencePoint node)
{
AssertExplicitSequencePointAllowed();
CSharpSyntaxNode syntax = node.Syntax;
if (this.emitSequencePoints)
{
if (syntax == null) //Null syntax indicates hidden sequence point (not equivalent to WasCompilerGenerated)
{
EmitHiddenSequencePoint();
}
else
{
EmitSequencePoint(syntax);
}
}
BoundStatement statement = node.StatementOpt;
int instructionsEmitted = 0;
if (statement != null)
{
instructionsEmitted = -builder.InstructionsEmitted;
this.EmitStatement(statement);
instructionsEmitted += builder.InstructionsEmitted;
}
if (instructionsEmitted == 0 && syntax != null && noOptimizations)
{
// if there was no code emitted, then emit nop
// otherwise this point could get associated with some random statement, possibly in a wrong scope
builder.EmitOpCode(ILOpCode.Nop);
}
}
/// <summary>
/// Add sequence point |here|:
///
/// foreach (Type var in |expr|) { }
/// </summary>
/// <remarks>
/// Hit once, before looping begins.
/// </remarks>
private void AddForEachExpressionSequencePoint(ForEachStatementSyntax forEachSyntax, ref BoundStatement collectionVarDecl)
{
if (this.generateDebugInfo)
{
// NOTE: This is slightly different from Dev10. In Dev10, when you stop the debugger
// on the collection expression, you can see the (uninitialized) iteration variable.
// In Roslyn, you cannot because the iteration variable is re-declared in each iteration
// of the loop and is, therefore, not yet in scope.
collectionVarDecl = new BoundSequencePoint(forEachSyntax.Expression, collectionVarDecl);
}
}
private BoundStatement RewriteForStatement(
SyntaxNode syntax,
ReadOnlyArray <LocalSymbol> locals,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
SyntaxNodeOrToken conditionSyntax,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
var startLabel = new GeneratedLabelSymbol("start");
var endLabel = new GeneratedLabelSymbol("end");
// for (initializer; condition; increment)
// body;
//
// becomes the following (with
// block added for locals)
//
// {
// initializer;
// goto end;
// start:
// body;
// continue:
// increment;
// end:
// GotoIfTrue condition start;
// break:
// }
// initializer;
// goto end;
var statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
//mark the initial jump as hidden.
//We do it to tell that this is not a part of previous statement.
//This jump may be a target of another jump (for example if loops are nested) and that will make
//impression of the previous statement being re-executed
var gotoEnd = new BoundSequencePoint(null, new BoundGotoStatement(syntax, endLabel));
statementBuilder.Add(gotoEnd);
// start:
// body;
statementBuilder.Add(new BoundLabelStatement(syntax, startLabel));
Debug.Assert(rewrittenBody != null);
statementBuilder.Add(rewrittenBody);
// continue:
// increment;
statementBuilder.Add(new BoundLabelStatement(syntax, continueLabel));
if (rewrittenIncrement != null)
{
statementBuilder.Add(rewrittenIncrement);
}
// end:
// GotoIfTrue condition start;
statementBuilder.Add(new BoundLabelStatement(syntax, endLabel));
BoundStatement branchBack = null;
if (rewrittenCondition != null)
{
branchBack = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel);
}
else
{
branchBack = new BoundGotoStatement(syntax, startLabel);
}
if (this.generateDebugInfo)
{
if (conditionSyntax.IsToken)
{
branchBack = new BoundSequencePointWithSpan(syntax, branchBack, conditionSyntax.Span);
}
else
{
//if there is no condition, make this a hidden point so that
//it does not count as a part of previous statement
branchBack = new BoundSequencePoint(conditionSyntax.AsNode(), branchBack);
}
}
statementBuilder.Add(branchBack);
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToReadOnlyAndFree();
return(new BoundBlock(syntax, locals, statements, hasErrors));
}
private BoundStatement RewriteForStatement(
SyntaxNode syntax,
ReadOnlyArray<LocalSymbol> locals,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
SyntaxNodeOrToken conditionSyntax,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
var startLabel = new GeneratedLabelSymbol("start");
var endLabel = new GeneratedLabelSymbol("end");
// for (initializer; condition; increment)
// body;
//
// becomes the following (with
// block added for locals)
//
// {
// initializer;
// goto end;
// start:
// body;
// continue:
// increment;
// end:
// GotoIfTrue condition start;
// break:
// }
// initializer;
// goto end;
var statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
//mark the initial jump as hidden.
//We do it to tell that this is not a part of previous statement.
//This jump may be a target of another jump (for example if loops are nested) and that will make
//impression of the previous statement being re-executed
var gotoEnd = new BoundSequencePoint(null, new BoundGotoStatement(syntax, endLabel));
statementBuilder.Add(gotoEnd);
// start:
// body;
statementBuilder.Add(new BoundLabelStatement(syntax, startLabel));
Debug.Assert(rewrittenBody != null);
statementBuilder.Add(rewrittenBody);
// continue:
// increment;
statementBuilder.Add(new BoundLabelStatement(syntax, continueLabel));
if (rewrittenIncrement != null)
{
statementBuilder.Add(rewrittenIncrement);
}
// end:
// GotoIfTrue condition start;
statementBuilder.Add(new BoundLabelStatement(syntax, endLabel));
BoundStatement branchBack = null;
if (rewrittenCondition != null)
{
branchBack = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel);
}
else
{
branchBack = new BoundGotoStatement(syntax, startLabel);
}
if (this.generateDebugInfo)
{
if (conditionSyntax.IsToken)
{
branchBack = new BoundSequencePointWithSpan(syntax, branchBack, conditionSyntax.Span);
}
else
{
//if there is no condition, make this a hidden point so that
//it does not count as a part of previous statement
branchBack = new BoundSequencePoint(conditionSyntax.AsNode(), branchBack);
}
}
statementBuilder.Add(branchBack);
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToReadOnlyAndFree();
return new BoundBlock(syntax, locals, statements, hasErrors);
}
private BoundStatement RewriteWhileStatement(
SyntaxNode syntax,
BoundExpression rewrittenCondition,
TextSpan conditionSequencePointSpan,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
var startLabel = new GeneratedLabelSymbol("start");
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel);
if (this.generateDebugInfo)
{
ifConditionGotoStart = new BoundSequencePointWithSpan(syntax, ifConditionGotoStart, conditionSequencePointSpan);
}
// while (condition)
// body;
//
// becomes
//
// goto continue;
// start:
// body
// continue:
// GotoIfTrue condition start;
// break:
BoundStatement gotoContinue = new BoundGotoStatement(syntax, continueLabel);
if (this.generateDebugInfo)
{
//mark the initial jump as hidden.
//We do it to tell that this is not a part of previou statement.
//This jump may be a target of another jump (for example if loops are nested) and that will make
//impression of the previous statement being re-executed
gotoContinue = new BoundSequencePoint(null, gotoContinue);
}
return BoundStatementList.Synthesized(syntax, hasErrors,
gotoContinue,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, continueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, breakLabel));
}
public override object VisitSequencePoint(BoundSequencePoint node, object arg)
{
return(null);
}