public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
BoundSpillSequenceBuilder builder = null;
var condition = VisitExpression(ref builder, node.Condition);
return(UpdateStatement(builder, node.Update(condition, node.JumpIfTrue, node.Label)));
}
private BoundStatement RewriteWhileStatement(
BoundLoopStatement loop,
BoundExpression rewrittenCondition,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(loop.Kind == BoundKind.WhileStatement || loop.Kind == BoundKind.ForEachStatement);
// while (condition)
// body;
//
// becomes
//
// goto continue;
// start:
// {
// body
// continue:
// GotoIfTrue condition start;
// }
// break:
SyntaxNode syntax = loop.Syntax;
var startLabel = new GeneratedLabelSymbol("start");
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel);
BoundStatement gotoContinue = new BoundGotoStatement(syntax, continueLabel);
if (this.Instrument && !loop.WasCompilerGenerated)
{
switch (loop.Kind)
{
case BoundKind.WhileStatement:
ifConditionGotoStart = _instrumenter.InstrumentWhileStatementConditionalGotoStartOrBreak((BoundWhileStatement)loop, ifConditionGotoStart);
break;
case BoundKind.ForEachStatement:
ifConditionGotoStart = _instrumenter.InstrumentForEachStatementConditionalGotoStart((BoundForEachStatement)loop, ifConditionGotoStart);
break;
default:
throw ExceptionUtilities.UnexpectedValue(loop.Kind);
}
// 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 would give the
// impression that the previous statement is 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 BoundStatement RewriteWhileStatement(
BoundLoopStatement loop,
BoundExpression rewrittenCondition,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(loop.Kind == BoundKind.WhileStatement || loop.Kind == BoundKind.ForEachStatement);
// while (condition)
// body;
//
// becomes
//
// goto continue;
// start:
// {
// body
// continue:
// GotoIfTrue condition start;
// }
// break:
SyntaxNode syntax = loop.Syntax;
var startLabel = new GeneratedLabelSymbol("start");
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, true, startLabel);
BoundStatement gotoContinue = new BoundGotoStatement(syntax, continueLabel);
if (this.Instrument && !loop.WasCompilerGenerated)
{
switch (loop.Kind)
{
case BoundKind.WhileStatement:
ifConditionGotoStart = _instrumenter.InstrumentWhileStatementConditionalGotoStartOrBreak((BoundWhileStatement)loop, ifConditionGotoStart);
break;
case BoundKind.ForEachStatement:
ifConditionGotoStart = _instrumenter.InstrumentForEachStatementConditionalGotoStart((BoundForEachStatement)loop, ifConditionGotoStart);
break;
default:
throw ExceptionUtilities.UnexpectedValue(loop.Kind);
}
// 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 would give the
// impression that the previous statement is 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 BoundStatement MakeSwitchStatementWithNullableExpression(
CSharpSyntaxNode syntax,
BoundExpression rewrittenExpression,
ImmutableArray <BoundSwitchSection> rewrittenSections,
LabelSymbol constantTargetOpt,
ImmutableArray <LocalSymbol> locals,
GeneratedLabelSymbol breakLabel,
BoundSwitchStatement oldNode)
{
Debug.Assert(rewrittenExpression.Type.IsNullableType());
var exprSyntax = rewrittenExpression.Syntax;
var exprNullableType = rewrittenExpression.Type;
var statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// Rewrite the nullable expression to a temp as we might have a user defined conversion from source expression to switch governing type.
// We can avoid generating the temp if the expression is a bound local.
LocalSymbol tempLocal;
if (rewrittenExpression.Kind != BoundKind.Local)
{
BoundAssignmentOperator assignmentToTemp;
BoundLocal boundTemp = this.factory.StoreToTemp(rewrittenExpression, out assignmentToTemp);
var tempAssignment = new BoundExpressionStatement(exprSyntax, assignmentToTemp);
statementBuilder.Add(tempAssignment);
tempLocal = boundTemp.LocalSymbol;
rewrittenExpression = boundTemp;
}
else
{
tempLocal = null;
}
// Generate a BoundConditionalGoto with null check as the conditional expression and appropriate switch label as the target: null, default or exit label.
BoundStatement condGotoNullValueTargetLabel = new BoundConditionalGoto(
exprSyntax,
condition: MakeNullCheck(exprSyntax, rewrittenExpression, BinaryOperatorKind.NullableNullEqual),
jumpIfTrue: true,
label: GetNullValueTargetSwitchLabel(rewrittenSections, breakLabel));
statementBuilder.Add(condGotoNullValueTargetLabel);
// Rewrite the switch statement using nullable expression's underlying value as the switch expression.
// rewrittenExpression.GetValueOrDefault()
MethodSymbol getValueOrDefault = GetNullableMethod(syntax, exprNullableType, SpecialMember.System_Nullable_T_GetValueOrDefault);
BoundCall callGetValueOrDefault = BoundCall.Synthesized(exprSyntax, rewrittenExpression, getValueOrDefault);
rewrittenExpression = callGetValueOrDefault;
// rewrite switch statement
BoundStatement rewrittenSwitchStatement = MakeSwitchStatementWithNonNullableExpression(syntax,
rewrittenExpression, rewrittenSections, constantTargetOpt, locals, breakLabel, oldNode);
statementBuilder.Add(rewrittenSwitchStatement);
return(new BoundBlock(syntax, locals: (object)tempLocal == null ? ImmutableArray <LocalSymbol> .Empty : ImmutableArray.Create <LocalSymbol>(tempLocal), statements: statementBuilder.ToImmutableAndFree()));
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
Debug.Assert(
node.Label == _currentFinallyFrame.ProxyLabelIfNeeded(node.Label),
"conditional leave?"
);
return(base.VisitConditionalGoto(node));
}
public override BoundNode VisitDoStatement(BoundDoStatement node)
{
Debug.Assert(node != null);
var rewrittenCondition = (BoundExpression)Visit(node.Condition);
var rewrittenBody = (BoundStatement)Visit(node.Body);
var startLabel = new GeneratedLabelSymbol("start");
var syntax = node.Syntax;
// EnC: We need to insert a hidden sequence point to handle function remapping in case
// the containing method is edited while methods invoked in the condition are being executed.
if (!node.WasCompilerGenerated && this.Instrument)
{
rewrittenCondition = _instrumenter.InstrumentDoStatementCondition(node, rewrittenCondition, _factory);
}
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(syntax, rewrittenCondition, true, startLabel);
if (!node.WasCompilerGenerated && this.Instrument)
{
ifConditionGotoStart = _instrumenter.InstrumentDoStatementConditionalGotoStart(node, ifConditionGotoStart);
}
// do
// body
// while (condition);
//
// becomes
//
// start:
// {
// body
// continue:
// sequence point
// GotoIfTrue condition start;
// }
// break:
if (node.Locals.IsEmpty)
{
return BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, node.BreakLabel));
}
return BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
new BoundBlock(syntax,
node.Locals,
ImmutableArray.Create<BoundStatement>(rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart)),
new BoundLabelStatement(syntax, node.BreakLabel));
}
public override BoundNode VisitDoStatement(BoundDoStatement node)
{
Debug.Assert(node != null);
var rewrittenCondition = (BoundExpression)Visit(node.Condition);
var rewrittenBody = (BoundStatement)Visit(node.Body);
var startLabel = new GeneratedLabelSymbol("start");
var syntax = node.Syntax;
// EnC: We need to insert a hidden sequence point to handle function remapping in case
// the containing method is edited while methods invoked in the condition are being executed.
if (!node.WasCompilerGenerated && this.Instrument)
{
rewrittenCondition = _instrumenter.InstrumentDoStatementCondition(node, rewrittenCondition, _factory);
}
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(syntax, rewrittenCondition, true, startLabel);
if (!node.WasCompilerGenerated && this.Instrument)
{
ifConditionGotoStart = _instrumenter.InstrumentDoStatementConditionalGotoStart(node, ifConditionGotoStart);
}
// do
// body
// while (condition);
//
// becomes
//
// start:
// {
// body
// continue:
// sequence point
// GotoIfTrue condition start;
// }
// break:
if (node.Locals.IsEmpty)
{
return(BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, node.BreakLabel)));
}
return(BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
new BoundBlock(syntax,
node.Locals,
ImmutableArray.Create <BoundStatement>(rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart)),
new BoundLabelStatement(syntax, node.BreakLabel)));
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
Debug.Assert(tempSubstitution.Count == 0);
BoundSpillSequenceBuilder builder = null;
var condition = VisitExpression(ref builder, node.Condition);
return(UpdateStatement(builder, node.Update(condition, node.JumpIfTrue, node.Label), substituteTemps: true));
}
public override BoundNode VisitDoStatement(BoundDoStatement node)
{
Debug.Assert(node != null);
var rewrittenCondition = (BoundExpression)Visit(node.Condition);
var rewrittenBody = (BoundStatement)Visit(node.Body);
var startLabel = new GeneratedLabelSymbol("start");
var syntax = node.Syntax;
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(syntax, rewrittenCondition, true, startLabel);
if (this.generateDebugInfo)
{
var doSyntax = (DoStatementSyntax)syntax;
var span = TextSpan.FromBounds(
doSyntax.WhileKeyword.SpanStart,
doSyntax.SemicolonToken.Span.End);
ifConditionGotoStart = new BoundSequencePointWithSpan(doSyntax, ifConditionGotoStart, span);
}
// do
// body
// while (condition);
//
// becomes
//
// start:
// {
// body
// continue:
// sequence point
// GotoIfTrue condition start;
// }
// break:
if (!node.InnerLocals.IsDefaultOrEmpty)
{
return(BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
new BoundBlock(syntax,
node.InnerLocals,
ImmutableArray.Create <BoundStatement>(rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart)),
new BoundLabelStatement(syntax, node.BreakLabel)));
}
return(BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, node.BreakLabel)));
}
public override BoundNode VisitDoStatement(BoundDoStatement node)
{
Debug.Assert(node != null);
var rewrittenCondition = (BoundExpression)Visit(node.Condition);
var rewrittenBody = (BoundStatement)Visit(node.Body);
var startLabel = new GeneratedLabelSymbol("start");
var syntax = node.Syntax;
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(syntax, AddConditionSequencePoint(rewrittenCondition, node), true, startLabel);
if (this.GenerateDebugInfo)
{
var doSyntax = (DoStatementSyntax)syntax;
var span = TextSpan.FromBounds(
doSyntax.WhileKeyword.SpanStart,
doSyntax.SemicolonToken.Span.End);
ifConditionGotoStart = new BoundSequencePointWithSpan(doSyntax, ifConditionGotoStart, span);
}
// do
// body
// while (condition);
//
// becomes
//
// start:
// {
// body
// continue:
// sequence point
// GotoIfTrue condition start;
// }
// break:
if (!node.InnerLocals.IsDefaultOrEmpty)
{
return BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
new BoundBlock(syntax,
node.InnerLocals,
ImmutableArray.Create<BoundStatement>(rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart)),
new BoundLabelStatement(syntax, node.BreakLabel));
}
return BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, node.BreakLabel));
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
BoundExpression condition = (BoundExpression)this.Visit(node.Condition);
if (condition.Kind != BoundKind.SpillSequence)
{
return node.Update(condition, node.JumpIfTrue, node.Label);
}
var spill = (BoundSpillSequence)condition;
return RewriteSpillSequenceAsBlock(spill,
node.Update(spill.Value, node.JumpIfTrue, node.Label));
}
private BoundStatement RewriteWhileStatement(
BoundWhileStatement loop,
ImmutableArray <LocalSymbol> locals,
BoundExpression rewrittenCondition,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
if (locals.IsEmpty)
{
return(RewriteWhileStatement(loop, rewrittenCondition, rewrittenBody, breakLabel, continueLabel, hasErrors));
}
// We need to enter scope-block from the top, that is where an instance of a display class will be created
// if any local is captured within a lambda.
// while (condition)
// body;
//
// becomes
//
// continue:
// {
// GotoIfFalse condition break;
// body
// goto continue;
// }
// break:
SyntaxNode syntax = loop.Syntax;
BoundStatement continueLabelStatement = new BoundLabelStatement(syntax, continueLabel);
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);
if (this.Instrument && !loop.WasCompilerGenerated)
{
ifNotConditionGotoBreak = _instrumenter.InstrumentWhileStatementConditionalGotoStartOrBreak(loop, ifNotConditionGotoBreak);
continueLabelStatement = new BoundSequencePoint(null, continueLabelStatement);
}
return(BoundStatementList.Synthesized(syntax, hasErrors,
continueLabelStatement,
new BoundBlock(syntax,
locals,
ImmutableArray.Create(
ifNotConditionGotoBreak,
rewrittenBody,
new BoundGotoStatement(syntax, continueLabel))),
new BoundLabelStatement(syntax, breakLabel)));
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
BoundExpression condition = (BoundExpression)this.Visit(node.Condition);
if (condition.Kind != BoundKind.SpillSequence)
{
return(node.Update(condition, node.JumpIfTrue, node.Label));
}
var spill = (BoundSpillSequence)condition;
return(RewriteSpillSequenceAsBlock(spill,
node.Update(spill.Value, node.JumpIfTrue, node.Label)));
}
private BoundStatement RewriteWhileStatement(
CSharpSyntaxNode 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 previous statement. This
// jump may be a target of another jump (for example if loops are nested) and that would give the
// impression that the previous statement is 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 BoundStatement RewriteWhileStatement(
CSharpSyntaxNode 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 previous statement. This
// jump may be a target of another jump (for example if loops are nested) and that would give the
// impression that the previous statement is 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 BoundNode VisitDoStatement(BoundDoStatement node)
{
Debug.Assert(node != null);
var rewrittenCondition = (BoundExpression)Visit(node.Condition);
var rewrittenBody = (BoundStatement)Visit(node.Body);
var startLabel = new GeneratedLabelSymbol("start");
var syntax = node.Syntax;
// EnC: We need to insert a hidden sequence point to handle function remapping in case
// the containing method is edited while methods invoked in the condition are being executed.
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(syntax, AddConditionSequencePoint(rewrittenCondition, node), true, startLabel);
if (this.GenerateDebugInfo)
{
var doSyntax = (DoStatementSyntax)syntax;
var span = TextSpan.FromBounds(
doSyntax.WhileKeyword.SpanStart,
doSyntax.SemicolonToken.Span.End);
ifConditionGotoStart = new BoundSequencePointWithSpan(doSyntax, ifConditionGotoStart, span);
}
// do
// body
// while (condition);
//
// becomes
//
// start:
// {
// body
// continue:
// sequence point
// GotoIfTrue condition start;
// }
// break:
return BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, node.BreakLabel));
}
public override BoundNode VisitDoStatement(BoundDoStatement node)
{
Debug.Assert(node != null);
var rewrittenCondition = (BoundExpression)Visit(node.Condition);
var rewrittenBody = (BoundStatement)Visit(node.Body);
var startLabel = new GeneratedLabelSymbol("start");
var syntax = node.Syntax;
// EnC: We need to insert a hidden sequence point to handle function remapping in case
// the containing method is edited while methods invoked in the condition are being executed.
BoundStatement ifConditionGotoStart = new BoundConditionalGoto(syntax, AddConditionSequencePoint(rewrittenCondition, node), true, startLabel);
if (this.GenerateDebugInfo)
{
var doSyntax = (DoStatementSyntax)syntax;
var span = TextSpan.FromBounds(
doSyntax.WhileKeyword.SpanStart,
doSyntax.SemicolonToken.Span.End);
ifConditionGotoStart = new BoundSequencePointWithSpan(doSyntax, ifConditionGotoStart, span);
}
// do
// body
// while (condition);
//
// becomes
//
// start:
// {
// body
// continue:
// sequence point
// GotoIfTrue condition start;
// }
// break:
return(BoundStatementList.Synthesized(syntax, node.HasErrors,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, node.ContinueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, node.BreakLabel)));
}
private BoundStatement RewriteForStatement(
CSharpSyntaxNode syntax,
ImmutableArray<LocalSymbol> outerLocals,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
CSharpSyntaxNode conditionSyntaxOpt,
TextSpan conditionSpanOpt,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(rewrittenBody != null);
// The sequence point behavior exhibited here is different from that of the native compiler. In the native
// compiler, if you have something like
//
// for([|int i = 0, j = 0|]; ; [|i++, j++|])
//
// then all the initializers are treated as a single sequence point, as are
// all the loop incrementors.
//
// We now make each one individually a sequence point:
//
// for([|int i = 0|], [|j = 0|]; ; [|i++|], [|j++|])
//
// If we decide that we want to preserve the native compiler stepping behavior
// then we'll need to be a bit fancy here. The initializer and increment statements
// can contain lambdas whose bodies need to have sequence points inserted, so we
// need to make sure we visit the children. But we'll also need to make sure that
// we do not generate one sequence point for each statement in the initializers
// and the incrementors.
var statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
// 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:
// }
var endLabel = new GeneratedLabelSymbol("end");
// initializer;
// goto end;
// 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));
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 (!conditionSpanOpt.IsEmpty)
{
branchBack = new BoundSequencePointWithSpan(syntax, branchBack, conditionSpanOpt);
}
else
{
// hidden sequence point if there is no condition
branchBack = new BoundSequencePoint(conditionSyntaxOpt, branchBack);
}
}
statementBuilder.Add(branchBack);
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return new BoundBlock(syntax, outerLocals, statements, hasErrors);
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
AddGoto(node.Label);
return(base.VisitConditionalGoto(node));
}
private BoundStatement RewriteForStatement(
CSharpSyntaxNode syntax,
ImmutableArray <LocalSymbol> outerLocals,
BoundStatement rewrittenInitializer,
ImmutableArray <LocalSymbol> innerLocals,
BoundExpression rewrittenCondition,
SyntaxNodeOrToken conditionSyntax,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(rewrittenBody != null);
// The sequence point behavior exhibited here is different from that of the native compiler. In the native
// compiler, if you have something like
//
// for(int i = 0, j = 0; ; i++, j++)
// ^--------------^ ^------^
//
// then all the initializers are treated as a single sequence point, as are
// all the loop incrementers.
//
// We now make each one individually a sequence point:
//
// for(int i = 0, j = 0; ; i++, j++)
// ^-------^ ^---^ ^-^ ^-^
//
// If we decide that we want to preserve the native compiler stepping behavior
// then we'll need to be a bit fancy here. The initializer and increment statements
// can contain lambdas whose bodies need to have sequence points inserted, so we
// need to make sure we visit the children. But we'll also need to make sure that
// we do not generate one sequence point for each statement in the initializers
// and the incrementers.
var statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
if (!innerLocals.IsDefaultOrEmpty)
{
var walker = new AnyLocalCapturedInALambdaWalker(innerLocals);
if (walker.Analyze(rewrittenCondition) || walker.Analyze(rewrittenIncrement) || walker.Analyze(rewrittenBody))
{
// If any inner local is captured within a lambda, we need to enter scope-block
// always from the top, that is where an instance of a display class will be created.
// The IL will be less optimal, but this shouldn't be a problem, given presence of lambdas.
// for (initializer; condition; increment)
// body;
//
// becomes the following (with
// block added for locals)
//
// {
// initializer;
// start:
// {
// GotoIfFalse condition break;
// body;
// continue:
// increment;
// goto start;
// }
// break:
// }
// start:
statementBuilder.Add(new BoundLabelStatement(syntax, startLabel));
var blockBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// GotoIfFalse condition break;
if (rewrittenCondition != null)
{
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);
if (this.generateDebugInfo)
{
if (conditionSyntax.IsToken)
{
ifNotConditionGotoBreak = new BoundSequencePointWithSpan(syntax, ifNotConditionGotoBreak, conditionSyntax.Span);
}
else
{
ifNotConditionGotoBreak = new BoundSequencePoint((CSharpSyntaxNode)conditionSyntax.AsNode(), ifNotConditionGotoBreak);
}
}
blockBuilder.Add(ifNotConditionGotoBreak);
}
// body;
blockBuilder.Add(rewrittenBody);
// continue:
// increment;
blockBuilder.Add(new BoundLabelStatement(syntax, continueLabel));
if (rewrittenIncrement != null)
{
blockBuilder.Add(rewrittenIncrement);
}
// goto start;
blockBuilder.Add(new BoundGotoStatement(syntax, startLabel));
statementBuilder.Add(new BoundBlock(syntax, innerLocals, blockBuilder.ToImmutableAndFree()));
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
return(new BoundBlock(syntax, outerLocals, statementBuilder.ToImmutableAndFree(), hasErrors));
}
}
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;
//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));
ArrayBuilder <BoundStatement> saveBuilder = null;
if (!innerLocals.IsDefaultOrEmpty)
{
saveBuilder = statementBuilder;
statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
}
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((CSharpSyntaxNode)conditionSyntax.AsNode(), branchBack);
}
}
statementBuilder.Add(branchBack);
if (!innerLocals.IsDefaultOrEmpty)
{
var block = new BoundBlock(syntax, innerLocals, statementBuilder.ToImmutableAndFree());
statementBuilder = saveBuilder;
statementBuilder.Add(block);
}
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return(new BoundBlock(syntax, outerLocals, statements, hasErrors));
}
/// <summary>
/// Generate a thread-safe accessor for a regular field-like event.
///
/// DelegateType tmp0 = _event; //backing field
/// DelegateType tmp1;
/// DelegateType tmp2;
/// do {
/// tmp1 = tmp0;
/// tmp2 = (DelegateType)Delegate.Combine(tmp1, value); //Remove for -=
/// tmp0 = Interlocked.CompareExchange<DelegateType>(ref _event, tmp2, tmp1);
/// } while ((object)tmp0 != (object)tmp1);
///
/// Note, if System.Threading.Interlocked.CompareExchange<T> is not available,
/// we emit the following code and mark the method Synchronized (unless it is a struct).
///
/// _event = (DelegateType)Delegate.Combine(_event, value); //Remove for -=
///
/// </summary>
internal static BoundBlock ConstructFieldLikeEventAccessorBody_Regular(SourceEventSymbol eventSymbol, bool isAddMethod, CSharpCompilation compilation, DiagnosticBag diagnostics)
{
CSharpSyntaxNode syntax = eventSymbol.CSharpSyntaxNode;
TypeSymbol delegateType = eventSymbol.Type;
MethodSymbol accessor = isAddMethod ? eventSymbol.AddMethod : eventSymbol.RemoveMethod;
ParameterSymbol thisParameter = accessor.ThisParameter;
TypeSymbol boolType = compilation.GetSpecialType(SpecialType.System_Boolean);
SpecialMember updateMethodId = isAddMethod ? SpecialMember.System_Delegate__Combine : SpecialMember.System_Delegate__Remove;
MethodSymbol updateMethod = (MethodSymbol)compilation.GetSpecialTypeMember(updateMethodId);
BoundStatement @return = new BoundReturnStatement(syntax,
expressionOpt: null)
{
WasCompilerGenerated = true
};
if (updateMethod == null)
{
MemberDescriptor memberDescriptor = SpecialMembers.GetDescriptor(updateMethodId);
diagnostics.Add(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_MissingPredefinedMember,
memberDescriptor.DeclaringTypeMetadataName,
memberDescriptor.Name),
syntax.Location));
return(new BoundBlock(syntax,
locals: ImmutableArray <LocalSymbol> .Empty,
statements: ImmutableArray.Create <BoundStatement>(@return))
{
WasCompilerGenerated = true
});
}
Binder.ReportUseSiteDiagnostics(updateMethod, diagnostics, syntax);
BoundThisReference fieldReceiver = eventSymbol.IsStatic ?
null :
new BoundThisReference(syntax, thisParameter.Type)
{
WasCompilerGenerated = true
};
BoundFieldAccess boundBackingField = new BoundFieldAccess(syntax,
receiver: fieldReceiver,
fieldSymbol: eventSymbol.AssociatedField,
constantValueOpt: null)
{
WasCompilerGenerated = true
};
BoundParameter boundParameter = new BoundParameter(syntax,
parameterSymbol: accessor.Parameters[0])
{
WasCompilerGenerated = true
};
BoundExpression delegateUpdate;
MethodSymbol compareExchangeMethod = (MethodSymbol)compilation.GetWellKnownTypeMember(WellKnownMember.System_Threading_Interlocked__CompareExchange_T);
if ((object)compareExchangeMethod == null)
{
// (DelegateType)Delegate.Combine(_event, value)
delegateUpdate = BoundConversion.SynthesizedNonUserDefined(syntax,
operand: BoundCall.Synthesized(syntax,
receiverOpt: null,
method: updateMethod,
arguments: ImmutableArray.Create <BoundExpression>(boundBackingField, boundParameter)),
kind: ConversionKind.ExplicitReference,
type: delegateType);
// _event = (DelegateType)Delegate.Combine(_event, value);
BoundStatement eventUpdate = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundBackingField,
right: delegateUpdate,
type: delegateType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
return(new BoundBlock(syntax,
locals: ImmutableArray <LocalSymbol> .Empty,
statements: ImmutableArray.Create <BoundStatement>(
eventUpdate,
@return))
{
WasCompilerGenerated = true
});
}
compareExchangeMethod = compareExchangeMethod.Construct(ImmutableArray.Create <TypeSymbol>(delegateType));
Binder.ReportUseSiteDiagnostics(compareExchangeMethod, diagnostics, syntax);
GeneratedLabelSymbol loopLabel = new GeneratedLabelSymbol("loop");
const int numTemps = 3;
LocalSymbol[] tmps = new LocalSymbol[numTemps];
BoundLocal[] boundTmps = new BoundLocal[numTemps];
for (int i = 0; i < numTemps; i++)
{
tmps[i] = new SynthesizedLocal(accessor, delegateType, SynthesizedLocalKind.LoweringTemp);
boundTmps[i] = new BoundLocal(syntax, tmps[i], null, delegateType);
}
// tmp0 = _event;
BoundStatement tmp0Init = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[0],
right: boundBackingField,
type: delegateType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// LOOP:
BoundStatement loopStart = new BoundLabelStatement(syntax,
label: loopLabel)
{
WasCompilerGenerated = true
};
// tmp1 = tmp0;
BoundStatement tmp1Update = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[1],
right: boundTmps[0],
type: delegateType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// (DelegateType)Delegate.Combine(tmp1, value)
delegateUpdate = BoundConversion.SynthesizedNonUserDefined(syntax,
operand: BoundCall.Synthesized(syntax,
receiverOpt: null,
method: updateMethod,
arguments: ImmutableArray.Create <BoundExpression>(boundTmps[1], boundParameter)),
kind: ConversionKind.ExplicitReference,
type: delegateType);
// tmp2 = (DelegateType)Delegate.Combine(tmp1, value);
BoundStatement tmp2Update = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[2],
right: delegateUpdate,
type: delegateType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// Interlocked.CompareExchange<DelegateType>(ref _event, tmp2, tmp1)
BoundExpression compareExchange = BoundCall.Synthesized(syntax,
receiverOpt: null,
method: compareExchangeMethod,
arguments: ImmutableArray.Create <BoundExpression>(boundBackingField, boundTmps[2], boundTmps[1]));
// tmp0 = Interlocked.CompareExchange<DelegateType>(ref _event, tmp2, tmp1);
BoundStatement tmp0Update = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[0],
right: compareExchange,
type: delegateType)
{
WasCompilerGenerated = true
})
{
WasCompilerGenerated = true
};
// tmp0 == tmp1 // i.e. exit when they are equal, jump to start otherwise
BoundExpression loopExitCondition = new BoundBinaryOperator(syntax,
operatorKind: BinaryOperatorKind.ObjectEqual,
left: boundTmps[0],
right: boundTmps[1],
constantValueOpt: null,
methodOpt: null,
resultKind: LookupResultKind.Viable,
type: boolType)
{
WasCompilerGenerated = true
};
// branchfalse (tmp0 == tmp1) LOOP
BoundStatement loopEnd = new BoundConditionalGoto(syntax,
condition: loopExitCondition,
jumpIfTrue: false,
label: loopLabel)
{
WasCompilerGenerated = true
};
return(new BoundBlock(syntax,
locals: tmps.AsImmutable(),
statements: ImmutableArray.Create <BoundStatement>(
tmp0Init,
loopStart,
tmp1Update,
tmp2Update,
tmp0Update,
loopEnd,
@return))
{
WasCompilerGenerated = true
});
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
BoundSpillSequence2 ss = null;
var condition = VisitExpression(ref ss, node.Condition);
return UpdateStatement(ss, node.Update(condition, node.JumpIfTrue, node.Label));
}
private BoundStatement RewriteForStatement(
BoundLoopStatement original,
ImmutableArray<LocalSymbol> outerLocals,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(original.Kind == BoundKind.ForStatement || original.Kind == BoundKind.ForEachStatement);
Debug.Assert(rewrittenBody != null);
// The sequence point behavior exhibited here is different from that of the native compiler. In the native
// compiler, if you have something like
//
// for([|int i = 0, j = 0|]; ; [|i++, j++|])
//
// then all the initializers are treated as a single sequence point, as are
// all the loop incrementors.
//
// We now make each one individually a sequence point:
//
// for([|int i = 0|], [|j = 0|]; ; [|i++|], [|j++|])
//
// If we decide that we want to preserve the native compiler stepping behavior
// then we'll need to be a bit fancy here. The initializer and increment statements
// can contain lambdas whose bodies need to have sequence points inserted, so we
// need to make sure we visit the children. But we'll also need to make sure that
// we do not generate one sequence point for each statement in the initializers
// and the incrementors.
SyntaxNode syntax = original.Syntax;
var statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
// 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:
// }
var endLabel = new GeneratedLabelSymbol("end");
// initializer;
// goto end;
BoundStatement gotoEnd = new BoundGotoStatement(syntax, endLabel);
if (this.Instrument)
{
switch (original.Kind)
{
case BoundKind.ForEachStatement:
gotoEnd = _instrumenter.InstrumentForEachStatementGotoEnd((BoundForEachStatement)original, gotoEnd);
break;
case BoundKind.ForStatement:
gotoEnd = _instrumenter.InstrumentForStatementGotoEnd((BoundForStatement)original, gotoEnd);
break;
default:
throw ExceptionUtilities.UnexpectedValue(original.Kind);
}
}
statementBuilder.Add(gotoEnd);
// start:
// body;
statementBuilder.Add(new BoundLabelStatement(syntax, startLabel));
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.Instrument)
{
switch (original.Kind)
{
case BoundKind.ForEachStatement:
branchBack = _instrumenter.InstrumentForEachStatementConditionalGotoStart((BoundForEachStatement)original, branchBack);
break;
case BoundKind.ForStatement:
branchBack = _instrumenter.InstrumentForStatementConditionalGotoStart((BoundForStatement)original, branchBack);
break;
default:
throw ExceptionUtilities.UnexpectedValue(original.Kind);
}
}
statementBuilder.Add(branchBack);
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return new BoundBlock(syntax, outerLocals, ImmutableArray<LocalFunctionSymbol>.Empty, statements, hasErrors);
}
private BoundStatement RewriteForStatement(
CSharpSyntaxNode syntax,
ImmutableArray <LocalSymbol> outerLocals,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
CSharpSyntaxNode conditionSyntaxOpt,
TextSpan conditionSpanOpt,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(rewrittenBody != null);
// The sequence point behavior exhibited here is different from that of the native compiler. In the native
// compiler, if you have something like
//
// for([|int i = 0, j = 0|]; ; [|i++, j++|])
//
// then all the initializers are treated as a single sequence point, as are
// all the loop incrementers.
//
// We now make each one individually a sequence point:
//
// for([|int i = 0|], [|j = 0|]; ; [|i++|], [|j++|])
//
// If we decide that we want to preserve the native compiler stepping behavior
// then we'll need to be a bit fancy here. The initializer and increment statements
// can contain lambdas whose bodies need to have sequence points inserted, so we
// need to make sure we visit the children. But we'll also need to make sure that
// we do not generate one sequence point for each statement in the initializers
// and the incrementers.
var statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
// 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:
// }
var endLabel = new GeneratedLabelSymbol("end");
// initializer;
// goto end;
// 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));
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 (!conditionSpanOpt.IsEmpty)
{
branchBack = new BoundSequencePointWithSpan(syntax, branchBack, conditionSpanOpt);
}
else
{
// hidden sequence point if there is no condition
branchBack = new BoundSequencePoint(conditionSyntaxOpt, branchBack);
}
}
statementBuilder.Add(branchBack);
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return(new BoundBlock(syntax, outerLocals, statements, hasErrors));
}
private BoundStatement RewriteWhileStatement(
CSharpSyntaxNode syntax,
ImmutableArray <LocalSymbol> innerLocals,
BoundExpression rewrittenCondition,
TextSpan conditionSequencePointSpan,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
if (!innerLocals.IsDefaultOrEmpty)
{
var walker = new AnyLocalCapturedInALambdaWalker(innerLocals);
if (walker.Analyze(rewrittenCondition) || walker.Analyze(rewrittenBody))
{
// If any inner local is captured within a lambda, we need to enter scope-block
// always from the top, that is where an instance of a display class will be created.
// The IL will be less optimal, but this shouldn't be a problem, given presence of lambdas.
// while (condition)
// body;
//
// becomes
//
// continue:
// {
// GotoIfFalse condition break;
// body
// goto continue;
// }
// break:
// TODO: We could perform more fine analysis.
// If locals declared in condition (the innerLocals) are captured, but not referenced in the body, we could use optimal IL by creating
// another block around the condition and use it as a scope for the locals declared in condition.
// This optimization can be applied to 'for' as well, while-body === for-body + increment.
// Note however that the scope adjusments will likely be observable during debugging, in locals window.
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);
if (this.generateDebugInfo)
{
ifNotConditionGotoBreak = new BoundSequencePointWithSpan(syntax, ifNotConditionGotoBreak, conditionSequencePointSpan);
}
return(BoundStatementList.Synthesized(syntax, hasErrors,
new BoundLabelStatement(syntax, continueLabel),
new BoundBlock(syntax,
innerLocals,
ImmutableArray.Create <BoundStatement>(
ifNotConditionGotoBreak,
rewrittenBody,
new BoundGotoStatement(syntax, continueLabel))),
new BoundLabelStatement(syntax, breakLabel)));
}
}
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 previous statement. This
// jump may be a target of another jump (for example if loops are nested) and that would give the
// impression that the previous statement is being re-executed.
gotoContinue = new BoundSequencePoint(null, gotoContinue);
}
if (!innerLocals.IsDefaultOrEmpty)
{
return(BoundStatementList.Synthesized(syntax, hasErrors,
gotoContinue,
new BoundLabelStatement(syntax, startLabel),
new BoundBlock(syntax,
innerLocals,
ImmutableArray.Create <BoundStatement>(
rewrittenBody,
new BoundLabelStatement(syntax, continueLabel),
ifConditionGotoStart)),
new BoundLabelStatement(syntax, breakLabel)));
}
return(BoundStatementList.Synthesized(syntax, hasErrors,
gotoContinue,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, continueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, breakLabel)));
}
private BoundStatement RewriteForStatement(
CSharpSyntaxNode syntax,
ImmutableArray<LocalSymbol> outerLocals,
BoundStatement rewrittenInitializer,
ImmutableArray<LocalSymbol> innerLocals,
BoundExpression rewrittenCondition,
SyntaxNodeOrToken conditionSyntax,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(rewrittenBody != null);
// The sequence point behavior exhibited here is different from that of the native compiler. In the native
// compiler, if you have something like
//
// for(int i = 0, j = 0; ; i++, j++)
// ^--------------^ ^------^
//
// then all the initializers are treated as a single sequence point, as are
// all the loop incrementers.
//
// We now make each one individually a sequence point:
//
// for(int i = 0, j = 0; ; i++, j++)
// ^-------^ ^---^ ^-^ ^-^
//
// If we decide that we want to preserve the native compiler stepping behavior
// then we'll need to be a bit fancy here. The initializer and increment statements
// can contain lambdas whose bodies need to have sequence points inserted, so we
// need to make sure we visit the children. But we'll also need to make sure that
// we do not generate one sequence point for each statement in the initializers
// and the incrementers.
var statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
if (!innerLocals.IsDefaultOrEmpty)
{
var walker = new AnyLocalCapturedInALambdaWalker(innerLocals);
if (walker.Analyze(rewrittenCondition) || walker.Analyze(rewrittenIncrement) || walker.Analyze(rewrittenBody))
{
// If any inner local is captured within a lambda, we need to enter scope-block
// always from the top, that is where an instance of a display class will be created.
// The IL will be less optimal, but this shouldn't be a problem, given presence of lambdas.
// for (initializer; condition; increment)
// body;
//
// becomes the following (with
// block added for locals)
//
// {
// initializer;
// start:
// {
// GotoIfFalse condition break;
// body;
// continue:
// increment;
// goto start;
// }
// break:
// }
// start:
statementBuilder.Add(new BoundLabelStatement(syntax, startLabel));
var blockBuilder = ArrayBuilder<BoundStatement>.GetInstance();
// GotoIfFalse condition break;
if (rewrittenCondition != null)
{
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);
if (this.generateDebugInfo)
{
if (conditionSyntax.IsToken)
{
ifNotConditionGotoBreak = new BoundSequencePointWithSpan(syntax, ifNotConditionGotoBreak, conditionSyntax.Span);
}
else
{
ifNotConditionGotoBreak = new BoundSequencePoint((CSharpSyntaxNode)conditionSyntax.AsNode(), ifNotConditionGotoBreak);
}
}
blockBuilder.Add(ifNotConditionGotoBreak);
}
// body;
blockBuilder.Add(rewrittenBody);
// continue:
// increment;
blockBuilder.Add(new BoundLabelStatement(syntax, continueLabel));
if (rewrittenIncrement != null)
{
blockBuilder.Add(rewrittenIncrement);
}
// goto start;
blockBuilder.Add(new BoundGotoStatement(syntax, startLabel));
statementBuilder.Add(new BoundBlock(syntax, innerLocals, blockBuilder.ToImmutableAndFree()));
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
return new BoundBlock(syntax, outerLocals, statementBuilder.ToImmutableAndFree(), hasErrors);
}
}
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;
//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));
ArrayBuilder<BoundStatement> saveBuilder = null;
if (!innerLocals.IsDefaultOrEmpty)
{
saveBuilder = statementBuilder;
statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
}
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((CSharpSyntaxNode)conditionSyntax.AsNode(), branchBack);
}
}
statementBuilder.Add(branchBack);
if (!innerLocals.IsDefaultOrEmpty)
{
var block = new BoundBlock(syntax, innerLocals, statementBuilder.ToImmutableAndFree());
statementBuilder = saveBuilder;
statementBuilder.Add(block);
}
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return new BoundBlock(syntax, outerLocals, statements, hasErrors);
}
private BoundStatement RewriteForStatement(
BoundLoopStatement original,
ImmutableArray <LocalSymbol> outerLocals,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
Debug.Assert(original.Kind == BoundKind.ForStatement || original.Kind == BoundKind.ForEachStatement);
Debug.Assert(rewrittenBody != null);
// The sequence point behavior exhibited here is different from that of the native compiler. In the native
// compiler, if you have something like
//
// for([|int i = 0, j = 0|]; ; [|i++, j++|])
//
// then all the initializers are treated as a single sequence point, as are
// all the loop incrementors.
//
// We now make each one individually a sequence point:
//
// for([|int i = 0|], [|j = 0|]; ; [|i++|], [|j++|])
//
// If we decide that we want to preserve the native compiler stepping behavior
// then we'll need to be a bit fancy here. The initializer and increment statements
// can contain lambdas whose bodies need to have sequence points inserted, so we
// need to make sure we visit the children. But we'll also need to make sure that
// we do not generate one sequence point for each statement in the initializers
// and the incrementors.
CSharpSyntaxNode syntax = original.Syntax;
var statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
// 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:
// }
var endLabel = new GeneratedLabelSymbol("end");
// initializer;
// goto end;
BoundStatement gotoEnd = new BoundGotoStatement(syntax, endLabel);
if (this.Instrument)
{
switch (original.Kind)
{
case BoundKind.ForEachStatement:
gotoEnd = _instrumenter.InstrumentForEachStatementGotoEnd((BoundForEachStatement)original, gotoEnd);
break;
case BoundKind.ForStatement:
gotoEnd = _instrumenter.InstrumentForStatementGotoEnd((BoundForStatement)original, gotoEnd);
break;
default:
throw ExceptionUtilities.UnexpectedValue(original.Kind);
}
}
statementBuilder.Add(gotoEnd);
// start:
// body;
statementBuilder.Add(new BoundLabelStatement(syntax, startLabel));
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.Instrument)
{
switch (original.Kind)
{
case BoundKind.ForEachStatement:
branchBack = _instrumenter.InstrumentForEachStatementConditionalGotoStart((BoundForEachStatement)original, branchBack);
break;
case BoundKind.ForStatement:
branchBack = _instrumenter.InstrumentForStatementConditionalGotoStart((BoundForStatement)original, branchBack);
break;
default:
throw ExceptionUtilities.UnexpectedValue(original.Kind);
}
}
statementBuilder.Add(branchBack);
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, breakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return(new BoundBlock(syntax, outerLocals, ImmutableArray <LocalFunctionSymbol> .Empty, statements, hasErrors));
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
Debug.Assert(node.Label == _currentFinallyFrame.ProxyLabelIfNeeded(node.Label), "conditional leave?");
return base.VisitConditionalGoto(node);
}
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
{
AddGoto(node.Label);
return base.VisitConditionalGoto(node);
}
private BoundStatement RewriteWhileStatement(
BoundWhileStatement loop,
ImmutableArray<LocalSymbol> locals,
BoundExpression rewrittenCondition,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
if (locals.IsEmpty)
{
return RewriteWhileStatement(loop, rewrittenCondition, rewrittenBody, breakLabel, continueLabel, hasErrors);
}
// We need to enter scope-block from the top, that is where an instance of a display class will be created
// if any local is captured within a lambda.
// while (condition)
// body;
//
// becomes
//
// continue:
// {
// GotoIfFalse condition break;
// body
// goto continue;
// }
// break:
SyntaxNode syntax = loop.Syntax;
BoundStatement continueLabelStatement = new BoundLabelStatement(syntax, continueLabel);
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);
if (this.Instrument && !loop.WasCompilerGenerated)
{
ifNotConditionGotoBreak = _instrumenter.InstrumentWhileStatementConditionalGotoStartOrBreak(loop, ifNotConditionGotoBreak);
continueLabelStatement = new BoundSequencePoint(null, continueLabelStatement);
}
return BoundStatementList.Synthesized(syntax, hasErrors,
continueLabelStatement,
new BoundBlock(syntax,
locals,
ImmutableArray.Create(
ifNotConditionGotoBreak,
rewrittenBody,
new BoundGotoStatement(syntax, continueLabel))),
new BoundLabelStatement(syntax, breakLabel));
}
/// <summary>
/// Generate a thread-safe accessor for a regular field-like event.
///
/// DelegateType tmp0 = _event; //backing field
/// DelegateType tmp1;
/// DelegateType tmp2;
/// do {
/// tmp1 = tmp0;
/// tmp2 = (DelegateType)Delegate.Combine(tmp1, value); //Remove for -=
/// tmp0 = Interlocked.CompareExchange<DelegateType>(ref _event, tmp2, tmp1);
/// } while ((object)tmp0 != (object)tmp1);
/// </summary>
internal static BoundBlock ConstructFieldLikeEventAccessorBody_Regular(SourceEventSymbol eventSymbol, bool isAddMethod, CSharpCompilation compilation, DiagnosticBag diagnostics)
{
CSharpSyntaxNode syntax = eventSymbol.CSharpSyntaxNode;
TypeSymbol delegateType = eventSymbol.Type;
MethodSymbol accessor = isAddMethod ? eventSymbol.AddMethod : eventSymbol.RemoveMethod;
ParameterSymbol thisParameter = accessor.ThisParameter;
TypeSymbol boolType = compilation.GetSpecialType(SpecialType.System_Boolean);
MethodSymbol updateMethod = (MethodSymbol)compilation.GetSpecialTypeMember(isAddMethod ? SpecialMember.System_Delegate__Combine : SpecialMember.System_Delegate__Remove);
MethodSymbol compareExchangeMethod = GetConstructedCompareExchangeMethod(delegateType, compilation, accessor.Locations[0], diagnostics);
if ((object)compareExchangeMethod == null)
{
return new BoundBlock(syntax,
locals: ImmutableArray<LocalSymbol>.Empty,
statements: ImmutableArray.Create<BoundStatement>(
new BoundReturnStatement(syntax,
expressionOpt: null)
{ WasCompilerGenerated = true }))
{ WasCompilerGenerated = true };
}
GeneratedLabelSymbol loopLabel = new GeneratedLabelSymbol("loop");
const int numTemps = 3;
LocalSymbol[] tmps = new LocalSymbol[numTemps];
BoundLocal[] boundTmps = new BoundLocal[numTemps];
for (int i = 0; i < numTemps; i++)
{
tmps[i] = new SynthesizedLocal(accessor, delegateType, SynthesizedLocalKind.LoweringTemp);
boundTmps[i] = new BoundLocal(syntax, tmps[i], null, delegateType);
}
BoundThisReference fieldReceiver = eventSymbol.IsStatic ?
null :
new BoundThisReference(syntax, thisParameter.Type) { WasCompilerGenerated = true };
BoundFieldAccess boundBackingField = new BoundFieldAccess(syntax,
receiver: fieldReceiver,
fieldSymbol: eventSymbol.AssociatedField,
constantValueOpt: null)
{ WasCompilerGenerated = true };
BoundParameter boundParameter = new BoundParameter(syntax,
parameterSymbol: accessor.Parameters[0])
{ WasCompilerGenerated = true };
// tmp0 = _event;
BoundStatement tmp0Init = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[0],
right: boundBackingField,
type: delegateType)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true };
// LOOP:
BoundStatement loopStart = new BoundLabelStatement(syntax,
label: loopLabel)
{ WasCompilerGenerated = true };
// tmp1 = tmp0;
BoundStatement tmp1Update = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[1],
right: boundTmps[0],
type: delegateType)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true };
// (DelegateType)Delegate.Combine(tmp1, value)
BoundExpression delegateUpdate = BoundConversion.SynthesizedNonUserDefined(syntax,
operand: BoundCall.Synthesized(syntax,
receiverOpt: null,
method: updateMethod,
arguments: ImmutableArray.Create<BoundExpression>(boundTmps[1], boundParameter)),
kind: ConversionKind.ExplicitReference,
type: delegateType);
// tmp2 = (DelegateType)Delegate.Combine(tmp1, value);
BoundStatement tmp2Update = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[2],
right: delegateUpdate,
type: delegateType)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true };
// Interlocked.CompareExchange<DelegateType>(ref _event, tmp2, tmp1)
BoundExpression compareExchange = BoundCall.Synthesized(syntax,
receiverOpt: null,
method: compareExchangeMethod,
arguments: ImmutableArray.Create<BoundExpression>(boundBackingField, boundTmps[2], boundTmps[1]));
// tmp0 = Interlocked.CompareExchange<DelegateType>(ref _event, tmp2, tmp1);
BoundStatement tmp0Update = new BoundExpressionStatement(syntax,
expression: new BoundAssignmentOperator(syntax,
left: boundTmps[0],
right: compareExchange,
type: delegateType)
{ WasCompilerGenerated = true })
{ WasCompilerGenerated = true };
// tmp0 == tmp1 // i.e. exit when they are equal, jump to start otherwise
BoundExpression loopExitCondition = new BoundBinaryOperator(syntax,
operatorKind: BinaryOperatorKind.ObjectEqual,
left: boundTmps[0],
right: boundTmps[1],
constantValueOpt: null,
methodOpt: null,
resultKind: LookupResultKind.Viable,
type: boolType)
{ WasCompilerGenerated = true };
// branchfalse (tmp0 == tmp1) LOOP
BoundStatement loopEnd = new BoundConditionalGoto(syntax,
condition: loopExitCondition,
jumpIfTrue: false,
label: loopLabel)
{ WasCompilerGenerated = true };
BoundStatement @return = new BoundReturnStatement(syntax,
expressionOpt: null)
{ WasCompilerGenerated = true };
return new BoundBlock(syntax,
locals: tmps.AsImmutable(),
statements: ImmutableArray.Create<BoundStatement>(
tmp0Init,
loopStart,
tmp1Update,
tmp2Update,
tmp0Update,
loopEnd,
@return))
{ WasCompilerGenerated = true };
}
private BoundStatement MakeSwitchStatementWithNullableExpression(
CSharpSyntaxNode syntax,
BoundExpression rewrittenExpression,
ImmutableArray<BoundSwitchSection> rewrittenSections,
LabelSymbol constantTargetOpt,
ImmutableArray<LocalSymbol> locals,
GeneratedLabelSymbol breakLabel,
BoundSwitchStatement oldNode)
{
Debug.Assert(rewrittenExpression.Type.IsNullableType());
var exprSyntax = rewrittenExpression.Syntax;
var exprNullableType = rewrittenExpression.Type;
var statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
// Rewrite the nullable expression to a temp as we might have a user defined conversion from source expression to switch governing type.
// We can avoid generating the temp if the expression is a bound local.
LocalSymbol tempLocal;
if (rewrittenExpression.Kind != BoundKind.Local)
{
BoundAssignmentOperator assignmentToTemp;
BoundLocal boundTemp = _factory.StoreToTemp(rewrittenExpression, out assignmentToTemp);
var tempAssignment = new BoundExpressionStatement(exprSyntax, assignmentToTemp);
statementBuilder.Add(tempAssignment);
tempLocal = boundTemp.LocalSymbol;
rewrittenExpression = boundTemp;
}
else
{
tempLocal = null;
}
// Generate a BoundConditionalGoto with null check as the conditional expression and appropriate switch label as the target: null, default or exit label.
BoundStatement condGotoNullValueTargetLabel = new BoundConditionalGoto(
exprSyntax,
condition: MakeNullCheck(exprSyntax, rewrittenExpression, BinaryOperatorKind.NullableNullEqual),
jumpIfTrue: true,
label: GetNullValueTargetSwitchLabel(rewrittenSections, breakLabel));
// Rewrite the switch statement using nullable expression's underlying value as the switch expression.
// rewrittenExpression.GetValueOrDefault()
MethodSymbol getValueOrDefault = GetNullableMethod(syntax, exprNullableType, SpecialMember.System_Nullable_T_GetValueOrDefault);
BoundCall callGetValueOrDefault = BoundCall.Synthesized(exprSyntax, rewrittenExpression, getValueOrDefault);
rewrittenExpression = callGetValueOrDefault;
// rewrite switch statement
BoundStatement rewrittenSwitchStatement = MakeSwitchStatementWithNonNullableExpression(
syntax,
condGotoNullValueTargetLabel,
rewrittenExpression,
rewrittenSections,
constantTargetOpt,
locals,
breakLabel,
oldNode);
statementBuilder.Add(rewrittenSwitchStatement);
return new BoundBlock(syntax, locals: (object)tempLocal == null ? ImmutableArray<LocalSymbol>.Empty : ImmutableArray.Create<LocalSymbol>(tempLocal), statements: statementBuilder.ToImmutableAndFree());
}
private BoundStatement RewriteForStatement(
BoundForStatement node,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody)
{
if (node.InnerLocals.IsEmpty)
{
return RewriteForStatementWithoutInnerLocals(
node,
node.OuterLocals,
rewrittenInitializer,
rewrittenCondition,
rewrittenIncrement,
rewrittenBody,
node.BreakLabel,
node.ContinueLabel, node.HasErrors);
}
// We need to enter inner_scope-block from the top, that is where an instance of a display class will be created
// if any local is captured within a lambda.
// for (initializer; condition; increment)
// body;
//
// becomes the following (with block added for locals)
//
// {
// initializer;
// start:
// {
// GotoIfFalse condition break;
// body;
// continue:
// increment;
// goto start;
// }
// break:
// }
Debug.Assert(rewrittenBody != null);
SyntaxNode syntax = node.Syntax;
var statementBuilder = ArrayBuilder<BoundStatement>.GetInstance();
// initializer;
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
// start:
BoundStatement startLabelStatement = new BoundLabelStatement(syntax, startLabel);
if (Instrument)
{
startLabelStatement = new BoundSequencePoint(null, startLabelStatement);
}
statementBuilder.Add(startLabelStatement);
var blockBuilder = ArrayBuilder<BoundStatement>.GetInstance();
// GotoIfFalse condition break;
if (rewrittenCondition != null)
{
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, node.BreakLabel);
if (this.Instrument)
{
ifNotConditionGotoBreak = _instrumenter.InstrumentForStatementConditionalGotoStartOrBreak(node, ifNotConditionGotoBreak);
}
blockBuilder.Add(ifNotConditionGotoBreak);
}
// body;
blockBuilder.Add(rewrittenBody);
// continue:
// increment;
blockBuilder.Add(new BoundLabelStatement(syntax, node.ContinueLabel));
if (rewrittenIncrement != null)
{
blockBuilder.Add(rewrittenIncrement);
}
// goto start;
blockBuilder.Add(new BoundGotoStatement(syntax, startLabel));
statementBuilder.Add(new BoundBlock(syntax, node.InnerLocals, blockBuilder.ToImmutableAndFree()));
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, node.BreakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return new BoundBlock(syntax, node.OuterLocals, statements, node.HasErrors);
}
private BoundStatement RewriteForStatement(
BoundForStatement node,
BoundStatement rewrittenInitializer,
BoundExpression rewrittenCondition,
BoundStatement rewrittenIncrement,
BoundStatement rewrittenBody)
{
if (node.InnerLocals.IsEmpty)
{
return(RewriteForStatementWithoutInnerLocals(
node,
node.OuterLocals,
rewrittenInitializer,
rewrittenCondition,
rewrittenIncrement,
rewrittenBody,
node.BreakLabel,
node.ContinueLabel, node.HasErrors));
}
// We need to enter inner_scope-block from the top, that is where an instance of a display class will be created
// if any local is captured within a lambda.
// for (initializer; condition; increment)
// body;
//
// becomes the following (with block added for locals)
//
// {
// initializer;
// start:
// {
// GotoIfFalse condition break;
// body;
// continue:
// increment;
// goto start;
// }
// break:
// }
Debug.Assert(rewrittenBody != null);
SyntaxNode syntax = node.Syntax;
var statementBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// initializer;
if (rewrittenInitializer != null)
{
statementBuilder.Add(rewrittenInitializer);
}
var startLabel = new GeneratedLabelSymbol("start");
// start:
BoundStatement startLabelStatement = new BoundLabelStatement(syntax, startLabel);
if (Instrument)
{
startLabelStatement = new BoundSequencePoint(null, startLabelStatement);
}
statementBuilder.Add(startLabelStatement);
var blockBuilder = ArrayBuilder <BoundStatement> .GetInstance();
// GotoIfFalse condition break;
if (rewrittenCondition != null)
{
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, node.BreakLabel);
if (this.Instrument)
{
ifNotConditionGotoBreak = _instrumenter.InstrumentForStatementConditionalGotoStartOrBreak(node, ifNotConditionGotoBreak);
}
blockBuilder.Add(ifNotConditionGotoBreak);
}
// body;
blockBuilder.Add(rewrittenBody);
// continue:
// increment;
blockBuilder.Add(new BoundLabelStatement(syntax, node.ContinueLabel));
if (rewrittenIncrement != null)
{
blockBuilder.Add(rewrittenIncrement);
}
// goto start;
blockBuilder.Add(new BoundGotoStatement(syntax, startLabel));
statementBuilder.Add(new BoundBlock(syntax, node.InnerLocals, blockBuilder.ToImmutableAndFree()));
// break:
statementBuilder.Add(new BoundLabelStatement(syntax, node.BreakLabel));
var statements = statementBuilder.ToImmutableAndFree();
return(new BoundBlock(syntax, node.OuterLocals, statements, node.HasErrors));
}
private BoundStatement RewriteWhileStatement(
CSharpSyntaxNode syntax,
ImmutableArray<LocalSymbol> innerLocals,
BoundExpression rewrittenCondition,
TextSpan conditionSequencePointSpan,
BoundStatement rewrittenBody,
GeneratedLabelSymbol breakLabel,
GeneratedLabelSymbol continueLabel,
bool hasErrors)
{
if (!innerLocals.IsDefaultOrEmpty)
{
var walker = new AnyLocalCapturedInALambdaWalker(innerLocals);
if (walker.Analyze(rewrittenCondition) || walker.Analyze(rewrittenBody))
{
// If any inner local is captured within a lambda, we need to enter scope-block
// always from the top, that is where an instance of a display class will be created.
// The IL will be less optimal, but this shouldn't be a problem, given presence of lambdas.
// while (condition)
// body;
//
// becomes
//
// continue:
// {
// GotoIfFalse condition break;
// body
// goto continue;
// }
// break:
// TODO: We could perform more fine analysis.
// If locals declared in condition (the innerLocals) are captured, but not referenced in the body, we could use optimal IL by creating
// another block around the condition and use it as a scope for the locals declared in condition.
// This optimization can be applied to 'for' as well, while-body === for-body + increment.
// Note however that the scope adjusments will likely be observable during debugging, in locals window.
BoundStatement ifNotConditionGotoBreak = new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, breakLabel);
if (this.GenerateDebugInfo)
{
ifNotConditionGotoBreak = new BoundSequencePointWithSpan(syntax, ifNotConditionGotoBreak, conditionSequencePointSpan);
}
return BoundStatementList.Synthesized(syntax, hasErrors,
new BoundLabelStatement(syntax, continueLabel),
new BoundBlock(syntax,
innerLocals,
ImmutableArray.Create(
ifNotConditionGotoBreak,
rewrittenBody,
new BoundGotoStatement(syntax, continueLabel))),
new BoundLabelStatement(syntax, breakLabel));
}
}
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 previous statement. This
// jump may be a target of another jump (for example if loops are nested) and that would give the
// impression that the previous statement is being re-executed.
gotoContinue = new BoundSequencePoint(null, gotoContinue);
}
if (!innerLocals.IsDefaultOrEmpty)
{
return BoundStatementList.Synthesized(syntax, hasErrors,
gotoContinue,
new BoundLabelStatement(syntax, startLabel),
new BoundBlock(syntax,
innerLocals,
ImmutableArray.Create<BoundStatement>(
rewrittenBody,
new BoundLabelStatement(syntax, continueLabel),
ifConditionGotoStart)),
new BoundLabelStatement(syntax, breakLabel));
}
return BoundStatementList.Synthesized(syntax, hasErrors,
gotoContinue,
new BoundLabelStatement(syntax, startLabel),
rewrittenBody,
new BoundLabelStatement(syntax, continueLabel),
ifConditionGotoStart,
new BoundLabelStatement(syntax, breakLabel));
}