protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // // ----> // // { // var <var> = <lower> // let upperBound = <upper> // while (<var> <= upperBound) // { // <body> // continue: // <var> = <var> + 1 // } // } var lowerBound = VariableDeclaration(node.Variable, node.LowerBound); var upperBound = ConstantDeclaration("upperBound", node.UpperBound); var result = Block(lowerBound, upperBound, While(LessOrEqual(Variable(lowerBound), Variable(upperBound)), Block(node.Body, Label(node.ContinueLabel), Increment(Variable(lowerBound))), node.BreakLabel, continueLabel: GenerateLabel()) ); return(RewriteStatement(result)); }
public override object VisitForStatement(BoundForStatement node, object arg) { VisitStatement(node.Initializer); LoopHead(node); bool isTrue; bool isFalse; if (node.Condition != null) { isFalse = IsConstantFalse(node.Condition); isTrue = IsConstantTrue(node.Condition); VisitCondition(node.Condition); } else { isTrue = true; isFalse = false; this.state = new FlowAnalysisLocalState(this.state.Reachable, this.state.Assigned, BitArray.AllSet(nextVariableSlot)); } var bodyState = new FlowAnalysisLocalState(this.state.Reachable && !isFalse, this.state.AssignedWhenTrue); var breakState = new FlowAnalysisLocalState(this.state.Reachable && !isTrue, this.state.AssignedWhenFalse); var oldPendingBranches = this.pendingBranches; this.pendingBranches = ArrayBuilder <PendingBranch> .GetInstance(); this.state = bodyState; VisitStatement(node.Body); ResolveContinues(node.ContinueLabel); VisitStatement(node.Increment); LoopTail(node); ResolveBreaks(oldPendingBranches, breakState, node.BreakLabel); return(null); }
protected override BoundStatement RewriteForStatement(BoundForStatement statement) { /* for(<assignment>, <condition>, <step>) <body> * * <assignment> * while (<condition>) { * body * step * } */ var whileStatements = ImmutableArray.CreateBuilder <BoundStatement>(); whileStatements.AddRange(new BoundStatement[] { statement.Body, new BoundLabel(statement.ContinueLabel), new BoundExpressionStatement(statement.Step) }); var whileStatement = new BoundWhileStatement(statement.Condition, new BoundBlock(whileStatements.ToImmutable()), statement.BreakLabel, statement.ContinueLabel, false); var finalStatements = ImmutableArray.CreateBuilder <BoundStatement>(); finalStatements.AddRange(new BoundStatement[] { statement.Assignment, whileStatement }); return(RewriteStatement(new BoundBlock(finalStatements.ToImmutable()))); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { //For Statements are now all While Statements var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var upperBoundSymbol = new VariableSymbol("upperBound", true, typeof(int)); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, typeof(int), typeof(int)), new BoundVariableExpression(upperBoundSymbol) ); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, typeof(int), typeof(int)), new BoundLiteralExpression(1) ) ) ); var whileBody = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBody); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement )); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { /* * { * let upperBound = <UpperBound> * <variable> = <lowerBound> * while <variable> < <UpperBound> * { * <statement> * <variable> = <variable> + 1 * } * } */ var upperBoundSymbol = new VariableSymbol("upperBound", true, node.UpperBound.Type, true); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var upperBoundExpression = new BoundVariableExpression(upperBoundSymbol); var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); // LowerBound shouldn't be rewriten? var variableExpression = new BoundVariableExpression(node.Variable); var conditionOperator = BoundBinaryOperator.Bind(SyntaxKind.LessToken, TypeSymbol.Int, TypeSymbol.Int); var condition = new BoundBinaryExpression(variableExpression, conditionOperator, upperBoundExpression); // UpperBound shouldn't be rewriten? var incrementOperator = BoundBinaryOperator.Bind(SyntaxKind.PlusToken, node.Variable.Type, TypeSymbol.Int); var increment = new BoundBinaryExpression(variableExpression, incrementOperator, new BoundLiteralExpression(1)); var incrementAssignment = new BoundAssignmentExpression(node.Variable, increment); var incrementStatement = new BoundExpressionStatement(incrementAssignment); var whileBlockStatement = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Statement, incrementStatement)); var whileStatement = new BoundWhileStatement(condition, whileBlockStatement); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(upperBoundDeclaration, variableDeclaration, whileStatement)); return(RewriteStatement(result)); }
private void EmitForStatement(BoundForStatement statement) { string beforeCheckLabel = this.GenerateJumpLabel(); string positiveLoopLabel = this.GenerateJumpLabel(); string negativeLoopLabel = this.GenerateJumpLabel(); string afterCheckLabel = this.GenerateJumpLabel(); string endOfBlockLabel = this.GenerateJumpLabel(); this.EmitExpression(statement.FromExpression); this.instructions.Add(new StoreVariableInstruction(statement.Identifier, statement.Syntax.IdentifierToken.Range)); this.instructions.Add(new TransientLabelInstruction(beforeCheckLabel, statement.Syntax.IdentifierToken.Range)); if (!statement.StepExpressionOpt.IsDefault()) { this.EmitExpression(statement.StepExpressionOpt); TextRange stepRange = statement.Syntax.StepClauseOpt.StepToken.Range; this.instructions.Add(new PushValueInstruction(new NumberValue(0), stepRange)); this.instructions.Add(new LessThanInstruction(stepRange)); this.instructions.Add(new TransientConditionalGoToInstruction(negativeLoopLabel, positiveLoopLabel, stepRange)); } TextRange toExpressionRange = statement.Syntax.ToExpression.Range; this.instructions.Add(new TransientLabelInstruction(positiveLoopLabel, toExpressionRange)); this.EmitExpression(statement.ToExpression); this.instructions.Add(new LoadVariableInstruction(statement.Identifier, toExpressionRange)); this.instructions.Add(new LessThanInstruction(toExpressionRange)); this.instructions.Add(new TransientConditionalGoToInstruction(endOfBlockLabel, afterCheckLabel, toExpressionRange)); this.instructions.Add(new TransientLabelInstruction(negativeLoopLabel, toExpressionRange)); this.instructions.Add(new LoadVariableInstruction(statement.Identifier, toExpressionRange)); this.EmitExpression(statement.ToExpression); this.instructions.Add(new LessThanInstruction(toExpressionRange)); this.instructions.Add(new TransientConditionalGoToInstruction(endOfBlockLabel, null, toExpressionRange)); this.instructions.Add(new TransientLabelInstruction(afterCheckLabel, toExpressionRange)); this.EmitBlockStatement(statement.Body); TextRange endForRange = statement.Syntax.EndForToken.Range; this.instructions.Add(new LoadVariableInstruction(statement.Identifier, endForRange)); if (statement.StepExpressionOpt.IsDefault()) { this.instructions.Add(new PushValueInstruction(new NumberValue(1), endForRange)); } else { this.EmitExpression(statement.StepExpressionOpt); } this.instructions.Add(new AddInstruction(endForRange)); this.instructions.Add(new StoreVariableInstruction(statement.Identifier, endForRange)); this.instructions.Add(new TransientUnconditionalGoToInstruction(beforeCheckLabel, endForRange)); this.instructions.Add(new TransientLabelInstruction(endOfBlockLabel, endForRange)); }
public override BoundNode VisitForStatement(BoundForStatement node) { if (IsInside) { _labelsInside.Add(node.BreakLabel); _labelsInside.Add(node.ContinueLabel); } return(base.VisitForStatement(node)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { /* * for <var> = <lower> to <upper> * <body> * * -----> * { * var <var> = <lower> * let upperBound = <upper> * while (<var> <= <upperBound>) * { * <body> * <var> = <var> + 1 * } * } */ // var <var> = <lower> var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); // let upperBound = <upper> var upperBoundSymbol = new VariableSymbol("upperBound", true, TypeSymbol.Int); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); // <var> var variableExpression = new BoundVariableExpression(node.Variable); //<var> <= <upperBound> var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, TypeSymbol.Int, TypeSymbol.Int), new BoundVariableExpression(upperBoundSymbol) ); // <var> = <var> + 1 var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1) ) ) ); var whileBlock = new BoundBlockStatement(ImmutableArray.Create(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBlock); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement)); return(RewriteStatement(result)); }
public override BoundNode VisitForStatement(BoundForStatement node) { var newOuterLocals = RewriteLocals(node.OuterLocals); BoundStatement initializer = (BoundStatement)this.Visit(node.Initializer); BoundExpression condition = (BoundExpression)this.Visit(node.Condition); BoundStatement increment = (BoundStatement)this.Visit(node.Increment); BoundStatement body = (BoundStatement)this.Visit(node.Body); return(node.Update(newOuterLocals, initializer, condition, increment, body, node.BreakLabel, node.ContinueLabel)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // // ----> // { // var <var> = <lower> // let upperBound = <upper> // while (<var> <= upperBound) // { // <body> // continue: // <var> = <var> + 1 // } // } var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var upperBoundSymbol = new LocalVariableSymbol("upperBound", true, TypeSymbol.Int); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, TypeSymbol.Int, TypeSymbol.Int), new BoundVariableExpression(upperBoundSymbol) ); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1) ) ) ); var whileBody = new BoundBlockStatement( ImmutableArray.Create <BoundStatement>( node.Body, continueLabelStatement, increment ) ); var whileStatement = new BoundWhileStatement(condition, whileBody, node.BreakLabel, GenerateLabel()); var result = new BoundBlockStatement( ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement ) ); return(RewriteStatement(result)); }
private void EvaluateForStatement(BoundForStatement node) { var lowerBound = (int)EvaluateExpression(node.LowerBound); var upperBound = (int)EvaluateExpression(node.UpperBound); for (var i = lowerBound; i <= upperBound; i++) { _variables[node.Variable] = i; EvaluateStatement(node.Body); } }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { var initializer = new BoundExpressionStatement(node.Initializer); var loop = new BoundExpressionStatement(node.Loop); var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var whileBlock = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Body, continueLabelStatement, loop)); var whileStatement = new BoundWhileStatement(node.Condition, whileBlock, node.BreakLabel, GenerateLabel()); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(initializer, whileStatement)); return(RewriteStatement(result)); }
public override BoundNode VisitForStatement(BoundForStatement node) { AddAll(node.OuterLocals); this.Visit(node.Initializer); AddAll(node.InnerLocals); this.Visit(node.Condition); this.Visit(node.Increment); this.Visit(node.Body); RemoveAll(node.InnerLocals); RemoveAll(node.OuterLocals); return(null); }
protected virtual BoundStatement RewriteForStatement(BoundForStatement statement) { var assignment = RewriteStatement(statement.Assignment); var cond = RewriteExpression(statement.Condition); var step = RewriteExpression(statement.Step); var body = RewriteStatement(statement.Body); if (assignment == statement.Assignment && cond == statement.Condition && step == statement.Step && body == statement.Body) { return(statement); } return(new BoundForStatement(assignment, cond, step, body, statement.BreakLabel, statement.ContinueLabel)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // // ----> // // { // var <var> = <lower> // while (<var> <= <upper>) // { // <body> // <var> = <var> + 1 // } // } var variableDeclaration = new BoundVeriableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var upperBoundSybmle = new VariableSymble("upperBound", true, typeof(int)); var upperBoundDeclaration = new BoundVeriableDeclaration(upperBoundSybmle, node.UpperBound); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualToken, typeof(int), typeof(int)), new BoundVariableExpression(upperBoundSybmle) ); var increment = new BoundExpressionStatemnet( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, typeof(int), typeof(int)), new BoundLiteralExpression(1) ) ) ); var whileBody = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBody); var result = new BoundBlockStatemnet(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperBoundDeclaration, whileStatement)); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { var condition = node.Condition; var continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); var increment = new BoundExpressionStatement( node.Action ); var whileBody = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( node.Body, continueLabelStatement, increment) ); var whileStatement = new BoundWhileStatement(condition, whileBody, node.BreakLabel, GenerateLabel()); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( node.Variable, whileStatement )); return(RewriteStatement(result)); }
protected virtual void VisitForStatement(BoundForStatement node) { if (node.Declarations != null) { VisitMultipleVariableDeclarations(node.Declarations); } if (node.Initializer != null) { VisitExpression(node.Initializer); } VisitExpression(node.Condition); if (node.Incrementor != null) { VisitExpression(node.Incrementor); } VisitStatement(node.Body); }
public override BoundNode VisitForStatement(BoundForStatement node) { Debug.Assert(node != null); var rewrittenInitializer = (BoundStatement)Visit(node.Initializer); var rewrittenCondition = (BoundExpression)Visit(node.Condition); var rewrittenIncrement = (BoundStatement)Visit(node.Increment); var rewrittenBody = (BoundStatement)Visit(node.Body); SyntaxNodeOrToken conditionSyntax = ((BoundNode)rewrittenCondition ?? node).Syntax; return(RewriteForStatement( node.Syntax, node.Locals, rewrittenInitializer, rewrittenCondition, conditionSyntax, rewrittenIncrement, rewrittenBody, node.BreakLabel, node.ContinueLabel, node.HasErrors)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { // for <var> = <lower> to <upper> // <body> // is rewritten to // { // var <Var> = <lower> // while () // var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); var variableExpression = new BoundVariableExpression(node.Variable); var condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, typeof(int), typeof(int)), node.UpperBound); var increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind( SyntaxKind.PlusToken, typeof(int), typeof(int)), new BoundLiteralExpression(1) ) ) ); var whileBlock = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Body, increment)); var whileStatement = new BoundWhileStatement(condition, whileBlock); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(variableDeclaration, whileStatement)); return(RewriteStatement(result)); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { BoundVariableDeclaration variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); BoundVariableExpression variableExpression = new BoundVariableExpression(node.Variable); VariableSymbol upperVariableSymbol = new LocalVariableSymbol("upperBound", true, TypeSymbol.Int); BoundVariableDeclaration upperVariableDeclaration = new BoundVariableDeclaration(upperVariableSymbol, node.UpperBound); BoundBinaryExpression condition = new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.LessOrEqualsToken, TypeSymbol.Int, TypeSymbol.Int), new BoundVariableExpression(upperVariableSymbol) ); BoundLabelStatement continueLabelStatement = new BoundLabelStatement(node.ContinueLabel); BoundExpressionStatement increment = new BoundExpressionStatement( new BoundAssignmentExpression( node.Variable, new BoundBinaryExpression( variableExpression, BoundBinaryOperator.Bind(SyntaxKind.PlusToken, TypeSymbol.Int, TypeSymbol.Int), new BoundLiteralExpression(1) ) ) ); BoundBlockStatement whileBody = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( node.Body, continueLabelStatement, increment )); BoundWhileStatement whileStatement = new BoundWhileStatement(condition, whileBody, node.BreakLabel, GenerateLabel()); BoundBlockStatement result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( variableDeclaration, upperVariableDeclaration, whileStatement )); return(RewriteStatement(result)); }
public override BoundNode VisitForStatement(BoundForStatement node) { Debug.Assert(node != null); var rewrittenInitializer = (BoundStatement)Visit(node.Initializer); var rewrittenCondition = (BoundExpression)Visit(node.Condition); var rewrittenIncrement = (BoundStatement)Visit(node.Increment); var rewrittenBody = (BoundStatement)Visit(node.Body); SyntaxNodeOrToken conditionSyntax = ((BoundNode)rewrittenCondition ?? node).Syntax; return RewriteForStatement( node.Syntax, node.Locals, rewrittenInitializer, rewrittenCondition, conditionSyntax, rewrittenIncrement, rewrittenBody, node.BreakLabel, node.ContinueLabel, node.HasErrors); }
public override BoundNode VisitForStatement(BoundForStatement node) { var newOuterLocals = RewriteLocals(node.OuterLocals); BoundStatement initializer = (BoundStatement)this.Visit(node.Initializer); var newInnerLocals = RewriteLocals(node.InnerLocals); BoundExpression condition = (BoundExpression)this.Visit(node.Condition); BoundStatement increment = (BoundStatement)this.Visit(node.Increment); BoundStatement body = (BoundStatement)this.Visit(node.Body); return node.Update(newOuterLocals, initializer, newInnerLocals, condition, increment, body, node.BreakLabel, node.ContinueLabel); }
protected override BoundStatement RewriteForStatement(BoundForStatement node) { /* * * for <decl>, <condition>, <increment> { * <body> * } * * * -----> * * { * <decl> * while <condition>{ * <body> * continue: * <increment> * } * break: * } * * * -----> * * * <decl> * goto check * body: * <body> * continue: * <increment> * check: * goto body if <condtiton> * break: */ var decl = node.VariableDeclaration; var increment = new BoundExpressionStatement(node.Increment, node.IsValid, true); var body = node.Body; var condition = node.Condition; var bodyLabel = CreateLabel(); var continueLabel = node.ContinueLabel; var checkLabel = CreateLabel(); var breakLabel = node.BreakLabel; var bodyLabelStmt = new BoundLabelStatement(bodyLabel, node.IsValid); var continueLabelStmt = new BoundLabelStatement(continueLabel, node.IsValid); var checkLabelStmt = new BoundLabelStatement(checkLabel, node.IsValid); var breakLabelStmt = new BoundLabelStatement(breakLabel, node.IsValid); var gotoCheck = new BoundGotoStatement(checkLabel, node.IsValid); var gotoTrueBody = new BoundConditionalGotoStatement(bodyLabel, node.Condition, jumpIfFalse: false, node.IsValid); var res = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>( decl, gotoCheck, bodyLabelStmt, body, continueLabelStmt, increment, checkLabelStmt, gotoTrueBody, breakLabelStmt ), node.IsValid); return(RewriteStatement(res)); }
protected virtual void VisitForStatement(BoundForStatement node) { if (node.Declarations != null) VisitMultipleVariableDeclarations(node.Declarations); if (node.Initializer != null) VisitExpression(node.Initializer); VisitExpression(node.Condition); if (node.Incrementor != null) VisitExpression(node.Incrementor); VisitStatement(node.Body); }
public override BoundNode VisitForStatement(BoundForStatement node) { throw ExceptionUtilities.Unreachable; // for statements have been lowered away by now }
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); 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)); }