public BoundForStatement(ForStatementSyntax syntax, BoundVariableDeclaration declaration, ImmutableArray<BoundExpression> initializers, BoundExpression condition, ImmutableArray<BoundExpression> incrementors, BoundStatement body)
: base(BoundNodeKind.ForStatement, syntax)
{
Declaration = declaration;
Initializers = initializers;
Condition = condition;
Incrementors = incrementors;
Body = body;
}
protected override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
if (!node.DescendentNodes().OfType<BlockSyntax>().Any())
{
node = node.Update (node.ForKeyword, node.OpenParenToken, node.DeclarationOpt,
node.Initializers, node.FirstSemicolonToken, node.ConditionOpt,
node.SecondSemicolonToken, node.Incrementors, node.CloseParenToken,
Syntax.Block (statements: node.Statement));
}
return base.VisitForStatement (node);
}
public BoundForStatement(
BoundStatement initStatement,
BoundExpression condition,
BoundStatement loopStatement,
BoundScopeStatement boundStatements,
ForStatementSyntax statementSyntax)
: base(statementSyntax)
{
InitStatement = initStatement;
Condition = condition;
LoopStatement = loopStatement;
BoundStatements = boundStatements;
}
public override void VisitForStatement(ForStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
mi.TryCatchUsingOrLoopSwitchStack.Push(false);
ContinueInfo ci = new ContinueInfo();
ci.Init(node.Statement);
m_ContinueInfoStack.Push(ci);
if (null != node.Declaration)
{
VisitVariableDeclaration(node.Declaration);
}
if (null != node.Initializers && node.Initializers.Count > 0)
{
foreach (var exp in node.Initializers)
{
CodeBuilder.AppendFormat("{0}", GetIndentString());
VisitToplevelExpression(exp, ";");
}
}
CodeBuilder.AppendFormat("{0}while( ", GetIndentString());
if (null != node.Condition)
{
var oper = m_Model.GetOperationEx(node) as IForLoopOperation;
IConversionOperation opd = null;
if (null != oper)
{
opd = oper.Condition as IConversionOperation;
}
OutputExpressionSyntax(node.Condition, opd);
}
else
{
CodeBuilder.Append("true");
}
CodeBuilder.AppendLine(" ){");
if (ci.HaveContinue)
{
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}local({1}); {1} = false;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}do{{", GetIndentString());
CodeBuilder.AppendLine();
}
++m_Indent;
node.Statement.Accept(this);
--m_Indent;
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}}}while(false);", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}if({1}){{break;}};", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
}
foreach (var exp in node.Incrementors)
{
CodeBuilder.AppendFormat("{0}", GetIndentString());
VisitToplevelExpression(exp, ";");
}
CodeBuilder.AppendFormat("{0}}};", GetIndentString());
CodeBuilder.AppendLine();
m_ContinueInfoStack.Pop();
mi.TryCatchUsingOrLoopSwitchStack.Pop();
}
public ForLoopBinder(Binder enclosing, ForStatementSyntax syntax)
: base(enclosing)
{
Debug.Assert(syntax != null);
_syntax = syntax;
}
protected override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
node = node.Update (node.ForKeyword, node.OpenParenToken, node.DeclarationOpt,
node.Initializers, node.FirstSemicolonToken, node.ConditionOpt,
node.SecondSemicolonToken, node.Incrementors, node.CloseParenToken,
GetLoopBlock (node.Statement));
this.loopLevel++;
var statement = base.VisitForStatement ((ForStatementSyntax)node.WithAdditionalAnnotations (this.isLoop));
this.loopLevel--;
return statement;
}
public override void VisitForStatement(ForStatementSyntax node)
{
base.VisitForStatement(node);
_counter++;
}
public override void VisitForStatement(ForStatementSyntax node)
{
parent.IncreaseComplexityByNestingPlusOne(node.ForKeyword);
parent.VisitWithNesting(node, base.VisitForStatement);
}
public virtual void VisitForStatement(ForStatementSyntax node)
{
DefaultVisit(node);
}
public override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
this.loopLevel++;
var statement = base.VisitForStatement (node
.WithStatement (GetLoopBlock (node.Statement)))
.WithAdditionalAnnotations (this.isLoop);
this.loopLevel--;
return statement;
}
private static async Task <Document> ConvertToIncrementingCounterForLoop(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
{
var condition = (BinaryExpressionSyntax)@for.Condition;
var newEndValue = @for.Declaration != null
? ((BinaryExpressionSyntax)@for.Declaration.Variables[0].Initializer.Value).Left
: ((BinaryExpressionSyntax)(@for.Initializers[0] as AssignmentExpressionSyntax).Right).Left;
var newStartValue = ((BinaryExpressionSyntax)@for.Condition).Right;
var newDeclaration = ReplaceStartValue(@for.Declaration, newStartValue);
var newInitializers = ReplaceStartValue(@for.Initializers, newStartValue);
var newCondition = condition
.WithOperatorToken(SyntaxFactory.Token(SyntaxKind.LessThanToken))
.WithRight(newEndValue);
return(await ReplaceFor(document, @for,
newDeclaration,
newInitializers,
newCondition,
cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (forEachStatement == null)
{
throw new ArgumentNullException(nameof(forEachStatement));
}
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(
semanticModel.GetDeclaredSymbol(forEachStatement),
document.Project.Solution,
cancellationToken).ConfigureAwait(false);
ForStatementSyntax forStatement = ForStatement(
declaration: VariableDeclaration(
PredefinedType(Token(SyntaxKind.IntKeyword)),
SingletonSeparatedList(
VariableDeclarator(CounterIdentifierName)
.WithInitializer(
EqualsValueClause(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(0)))))),
initializers: SeparatedList <ExpressionSyntax>(),
condition: BinaryExpression(
SyntaxKind.LessThanExpression,
IdentifierName(CounterIdentifierName),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(forEachStatement.Expression.ToString()),
IdentifierName(GetCountOrLengthPropertyName(forEachStatement.Expression, semanticModel)))),
incrementors: SingletonSeparatedList <ExpressionSyntax>(
PostfixUnaryExpression(
SyntaxKind.PostIncrementExpression,
IdentifierName(CounterIdentifierName))),
statement: forEachStatement.Statement.ReplaceNodes(
GetIdentifiers(root, referencedSymbols),
(f, g) =>
{
return(ElementAccessExpression(
IdentifierName(forEachStatement.Expression.ToString()),
BracketedArgumentList(
SingletonSeparatedList(Argument(IdentifierName(CounterIdentifierName))))
).WithTriviaFrom(f));
}));
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithFormatterAnnotation();
root = root.ReplaceNode(forEachStatement, forStatement);
return(document.WithSyntaxRoot(root));
}
public override void VisitForStatement(ForStatementSyntax node)
{
reset();
isFor = true;
base.VisitForStatement(node);
}
public void VisitForStatement(ForStatementSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
_writer.WriteKeyword(PrinterKeyword.For);
if (_writer.Configuration.Spaces.BeforeParentheses.ForParentheses)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.OpenParen);
if (_writer.Configuration.Other.AlignMultiLineConstructs.ForStatementHeader)
_writer.SetAlignmentBreak(true);
if (_writer.Configuration.Spaces.WithinParentheses.ForParentheses)
_writer.WriteSpace();
bool hadOne = false;
if (node.Declaration != null)
node.Declaration.Accept(this);
foreach (var initializer in node.Initializers)
{
if (hadOne)
_writer.WriteListSeparator();
else
hadOne = true;
initializer.Accept(this);
}
_writer.WriteStatementSeparator(_writer.Configuration.LineBreaksAndWrapping.LineWrapping.WrapForStatementHeader);
if (node.Condition != null)
node.Condition.Accept(this);
_writer.WriteStatementSeparator(_writer.Configuration.LineBreaksAndWrapping.LineWrapping.WrapForStatementHeader);
hadOne = false;
foreach (var incrementor in node.Incrementors)
{
if (hadOne)
_writer.WriteListSeparator();
else
hadOne = true;
incrementor.Accept(this);
}
if (_writer.Configuration.Spaces.WithinParentheses.ForParentheses)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.CloseParen);
if (_writer.Configuration.Other.AlignMultiLineConstructs.ForStatementHeader)
_writer.SetAlignmentBreak(false);
VisitBlockStatement(node.Statement);
WriteTrailingTrivia(node);
}
public void Flatten(ForStatementSyntax node, List<FlatStatement> instructions)
{
this.PushVariableScope(instructions);
// variable declarations
Flatten(node.Declaration, instructions);
string forPrefix = this.MakeUniqueLabelPrefix("for");
string conditionCheckLabel = forPrefix + "conditionCheck"; // WHERE THE CONTINUE GOES!
string incrementLabel = forPrefix + "increment";
string endForLabel = forPrefix + "end"; // WHERE THE BREAK GOES
string wasContinue = this.SetContinueLabel(incrementLabel);
string wasBreak = this.SetBreakLabel(endForLabel);
string beginForLabel = forPrefix + "begin"; // WHERE YOUR MOM GOES
// check conditions
instructions.Add(FlatStatement.LABEL(FlatOperand.LabelRef(conditionCheckLabel)));
FlattenCondition(node.Condition, forPrefix, false, endForLabel, instructions);
// drop statement
instructions.Add(FlatStatement.LABEL(FlatOperand.LabelRef(beginForLabel)));
this.FlattenStatement(node.Statement, instructions);
// increment
instructions.Add(FlatStatement.LABEL(FlatOperand.LabelRef(incrementLabel)));
foreach (ExpressionSyntax es in node.Incrementors)
{
FlatOperand fop_incresult = this.ResolveExpression(es, null, instructions);
}
// jump to check conditions
instructions.Add(FlatStatement.JMP(FlatOperand.LabelRef(conditionCheckLabel)));
// end
instructions.Add(FlatStatement.LABEL(FlatOperand.LabelRef(endForLabel)));
this.PopVariableScope(instructions);
this.SetContinueLabel(wasContinue);
this.SetBreakLabel(wasBreak);
}
private bool IsEmptyForStatement(ForStatementSyntax forStatement) => forStatement.Initializers.Count == 0 && forStatement.Declaration == null && forStatement.Condition == null && forStatement.Incrementors.Count == 0;
private static bool CaretIsInForStatementInitializers(int caretPosition, ForStatementSyntax forStatementSyntax) => forStatementSyntax.Initializers.Count != 0 && caretPosition > forStatementSyntax.Initializers.Span.Start && caretPosition <= forStatementSyntax.Initializers.Span.End;
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitForStatement(ForStatementSyntax node)
{
this.VisitStatement(node);
}
public override void VisitForStatement(ForStatementSyntax node)
{
}
private void HighlightForStatement(ForStatementSyntax statement, List <TextSpan> spans)
{
spans.Add(statement.ForKeyword.Span);
}
public override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
node = (ForStatementSyntax)base.VisitForStatement(node);
if (!node.CloseParenToken.IsMissing && node.Statement.Kind != SyntaxKind.Block)
{
return CodeAnnotations.Formatting.AddAnnotationTo(
Syntax.ForStatement(
node.ForKeyword,
node.OpenParenToken,
node.Declaration,
node.Initializers,
node.FirstSemicolonToken,
node.Condition,
node.SecondSemicolonToken,
node.Incrementors,
node.CloseParenToken,
WrapStatementWithBlock(node.Statement)));
}
else
{
return node;
}
}
public override void VisitForStatement(ForStatementSyntax node)
{
VisitStatementIfNotNull(node.Statement);
}
public virtual void Visit(ForStatementSyntax forStatementSyntax)
{
Visit(forStatementSyntax.InitStatement);
Visit(forStatementSyntax.CondExpression);
Visit(forStatementSyntax.LoopStatement);
Visit(forStatementSyntax.Statements);
}
public override void VisitForStatement(ForStatementSyntax node)
{
Emit <ForBlock, ForStatementSyntax>(node);
}
public override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
return(node);
}
public ForStatementInterpreter(StatementInterpreterHandler statementInterpreterHandler, ForStatementSyntax forStatementSyntax)
{
this.statementInterpreterHandler = statementInterpreterHandler;
this.forStatementSyntax = forStatementSyntax;
}
public virtual void VisitForStatement(ForStatementSyntax node)
{
DefaultVisit(node);
}
private BoundForStatement BindForStatement(ForStatementSyntax syntax, Symbol parent)
{
BindAttributes(syntax.Attributes);
var forStatementBinder = new Binder(_sharedBinderState, this);
// Note that we bind declarations in the current scope, not the for statement scope.
return new BoundForStatement(
syntax.Declaration != null ? Bind(syntax.Declaration, x => BindForStatementDeclaration(x, parent)) : null,
syntax.Initializer != null ? forStatementBinder.Bind(syntax.Initializer, forStatementBinder.BindExpression) : null,
forStatementBinder.Bind(syntax.Condition, forStatementBinder.BindExpression),
syntax.Incrementor != null ? forStatementBinder.Bind(syntax.Incrementor, forStatementBinder.BindExpression) : null,
forStatementBinder.Bind(syntax.Statement, x => forStatementBinder.BindStatement(x, parent)));
}
public static Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
SemanticModel semanticModel,
bool reverseLoop = false,
CancellationToken cancellationToken = default)
{
string name = NameGenerator.Default.EnsureUniqueLocalName(
DefaultNames.ForVariable,
semanticModel,
forEachStatement.Statement.SpanStart,
cancellationToken: cancellationToken);
SyntaxToken identifier = Identifier(name);
if (name != DefaultNames.ForVariable)
{
identifier = identifier.WithRenameAnnotation();
}
ExpressionSyntax forEachExpression = forEachStatement.Expression;
MemberAccessExpressionSyntax countOrLengthMemberAccess = SimpleMemberAccessExpression(
forEachExpression.WithoutTrivia(),
IdentifierName(CSharpUtility.GetCountOrLengthPropertyName(forEachExpression, semanticModel, cancellationToken)));
VariableDeclarationSyntax declaration;
BinaryExpressionSyntax condition;
PostfixUnaryExpressionSyntax incrementor;
if (reverseLoop)
{
declaration = VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(
SubtractExpression(
countOrLengthMemberAccess,
NumericLiteralExpression(1))));
condition = GreaterThanOrEqualExpression(IdentifierName(name), NumericLiteralExpression(0));
incrementor = PostDecrementExpression(IdentifierName(name));
}
else
{
declaration = VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(NumericLiteralExpression(0)));
condition = LessThanExpression(
IdentifierName(name),
countOrLengthMemberAccess);
incrementor = PostIncrementExpression(IdentifierName(name));
}
StatementSyntax statement = forEachStatement.Statement.ReplaceNodes(
GetVariableReferences(forEachStatement, semanticModel, cancellationToken),
(node, _) =>
{
return(ElementAccessExpression(
forEachExpression.WithoutTrivia(),
BracketedArgumentList(SingletonSeparatedList(Argument(IdentifierName(name))))
).WithTriviaFrom(node));
});
ForStatementSyntax forStatement = ForStatement(
declaration: declaration,
initializers: default(SeparatedSyntaxList <ExpressionSyntax>),
condition: condition,
incrementors: SingletonSeparatedList <ExpressionSyntax>(incrementor),
statement: statement);
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(forEachStatement, forStatement, cancellationToken));
}
public ForLoopBinder(MethodSymbol owner, Binder enclosing, ForStatementSyntax syntax)
: base(owner, enclosing)
{
Debug.Assert(syntax != null);
this.syntax = syntax;
}
private static void RegisterForStatementConditionRemoval(CodeFixContext context, SyntaxNode root, ForStatementSyntax forStatement)
{
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var newRoot = root.ReplaceNode(
forStatement,
forStatement.WithCondition(null).WithAdditionalAnnotations(Formatter.Annotation));
return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot)));
}),
context.Diagnostics);
}
static async Task <Document> ReplaceForAsync(Document document, ForStatementSyntax oldFor, ForStatementSyntax newFor, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = root.ReplaceNode(oldFor, newFor);
return(document.WithSyntaxRoot(newRoot));
}
private static bool CaretIsInForStatementDeclaration(int caretPosition, ForStatementSyntax forStatementSyntax) => forStatementSyntax.Declaration != null && caretPosition > forStatementSyntax.Declaration.Span.Start && caretPosition <= forStatementSyntax.Declaration.Span.End;
private static async Task <Document> ConvertToDecrementingCounterForLoopAsync(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
{
var condition = (BinaryExpressionSyntax)@for.Condition;
var newEndValue = @for.Declaration != null
? @for.Declaration.Variables[0].Initializer.Value
: (@for.Initializers[0] as AssignmentExpressionSyntax).Right;
var newStartValue = SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, condition.Right, One);
var newDeclaration = ReplaceStartValue(@for.Declaration, newStartValue);
var newInitializers = ReplaceStartValue(@for.Initializers, newStartValue);
var newCondition = condition
.WithOperatorToken(SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken))
.WithRight(newEndValue);
return(await ReplaceForAsync(document, @for,
newDeclaration,
newInitializers,
newCondition,
cancellationToken));
}
public override void VisitForStatement(ForStatementSyntax node)
{
AddLocation(node.ForKeyword);
base.VisitForStatement(node);
}
private Doc PrintForStatementSyntax(ForStatementSyntax node)
{
var parts = new Parts(
this.PrintExtraNewLines(node),
this.PrintSyntaxToken(node.ForKeyword, " "),
this.PrintSyntaxToken(node.OpenParenToken)
);
var innerGroup = new Parts();
innerGroup.Push(SoftLine);
if (node.Declaration != null)
{
innerGroup.Push(
this.PrintVariableDeclarationSyntax(node.Declaration)
);
}
innerGroup.Push(
this.PrintSeparatedSyntaxList(
node.Initializers,
this.Print,
" "
)
);
innerGroup.Push(this.PrintSyntaxToken(node.FirstSemicolonToken));
if (node.Condition != null)
{
innerGroup.Push(Line, this.Print(node.Condition));
}
else
{
innerGroup.Push(SoftLine);
}
innerGroup.Push(this.PrintSyntaxToken(node.SecondSemicolonToken));
if (node.Incrementors.Any())
{
innerGroup.Push(Line);
}
else
{
innerGroup.Push(SoftLine);
}
innerGroup.Push(
Indent(
this.PrintSeparatedSyntaxList(
node.Incrementors,
this.Print,
Line
)
)
);
parts.Push(Group(Indent(innerGroup.ToArray())));
parts.Push(this.PrintSyntaxToken(node.CloseParenToken));
var statement = this.Print(node.Statement);
if (node.Statement is BlockSyntax)
{
parts.Push(statement);
}
else
{
// TODO 1 force braces? we do in if and else
parts.Push(Indent(Concat(HardLine, statement)));
}
return(Concat(parts));
}
public override void VisitForStatement(ForStatementSyntax node) => counter.CheckNesting(node.ForKeyword, () => base.VisitForStatement(node));
public override void VisitForStatement(ForStatementSyntax node) => IncrementComplexity(() => base.VisitForStatement(node));
internal static void Analyze(SyntaxNodeAnalysisContext context, ForStatementSyntax forStatement)
{
Analyze(context, forStatement, forStatement.CloseParenToken, forStatement.Statement);
}
public static void Go(OutputWriter writer, ForStatementSyntax forStatement)
{
// writer.WriteLine(); // Beautify the code ...
var tempWriter = new TempWriter();
tempWriter.Indent = writer.Indent;
var initializers = forStatement.Initializers;
var initCount = initializers.Count + (forStatement.Declaration != null?forStatement.Declaration.Variables.Count :0);
if (initCount > 1)
{
tempWriter.WriteLine("//For loop");
tempWriter.OpenBrace();
foreach (var init in initializers)
{
tempWriter.WriteLine(Core.WriteString(init, false, tempWriter.Indent) + ";");
}
if (forStatement.Declaration != null)
{
var variables = forStatement.Declaration.Variables;
foreach (var variable in variables)
{
var vardec = (TypeProcessor.ConvertType(forStatement.Declaration.Type) + " ");
vardec += (WriteIdentifierName.TransformIdentifier(variable.Identifier.Text));
if (variable.Initializer != null)
{
vardec += (" = ");
vardec += Core.WriteString(variable.Initializer.Value, false, tempWriter.Indent);
}
tempWriter.WriteLine(vardec + ";");
}
}
}
tempWriter.Write("\r\n");
tempWriter.WriteIndent();
tempWriter.Write("for (");
if (initCount == 1)
{
foreach (var init in initializers)
{
Core.Write(tempWriter, init);
if (init != initializers.Last())
{
tempWriter.Write(",");
}
}
if (forStatement.Declaration != null)
{
var variables = forStatement.Declaration.Variables;
foreach (var variable in variables)
{
// writer.WriteIndent();
tempWriter.Write(TypeProcessor.ConvertType(forStatement.Declaration.Type) + " ");
tempWriter.Write(WriteIdentifierName.TransformIdentifier(variable.Identifier.Text));
if (variable.Initializer != null)
{
tempWriter.Write(" = ");
Core.Write(tempWriter, variable.Initializer.Value);
}
if (variable != variables.LastOrDefault())
{
tempWriter.Write(",");
}
}
}
}
tempWriter.Write(";");
if (forStatement.Condition == null)
{
tempWriter.Write("true");
}
else
{
Core.Write(tempWriter, forStatement.Condition);
}
tempWriter.Write(";");
foreach (var iterator in forStatement.Incrementors)
{
Core.Write(tempWriter, iterator);
if (iterator != forStatement.Incrementors.LastOrDefault())
{
tempWriter.Write(",");
}
}
tempWriter.Write(")");
writer.WriteLine(tempWriter.ToString());
writer.OpenBrace();
Core.WriteStatementAsBlock(writer, forStatement.Statement, false);
writer.CloseBrace();
if (initCount > 1)
{
writer.CloseBrace();
writer.WriteLine("//End of for loop");
}
// writer.WriteLine(); // Beautify the code ...
}
internal ForInitializerBlock(ForStatementSyntax forNode, Block successor)
: base(successor)
{
ForNode = forNode ?? throw new ArgumentNullException(nameof(forNode));
}
private BoundStatement BindForStatement(ForStatementSyntax syntax)
{
var boundInitStatement = BindStatement(syntax.InitStatement);
var boundCondition = BindExpression(syntax.CondExpression);
Ensure(() => TypeEquals(boundCondition.Type, new BoolCompilerGeneratedType()), "For condition must be of Type Bool");
var boundLoopStatement = BindStatement(syntax.LoopStatement);
var boundStatements = BindScope(syntax.Statements);
return new BoundForStatement(boundInitStatement, boundCondition, boundLoopStatement, boundStatements, syntax);
}
