private void EmitStatementList(BoundStatementList list)
{
for (int i = 0, n = list.Statements.Length; i < n; i++)
{
EmitStatement(list.Statements[i]);
}
}
/// <summary>
/// Add sequence point |here|:
///
/// |foreach| (Type var in expr) { }
/// </summary>
/// <remarks>
/// Hit once, before looping begins.
/// </remarks>
private void AddForEachKeywordSequencePoint(ForEachStatementSyntax forEachSyntax, ref BoundStatement result)
{
if (this.generateDebugInfo)
{
BoundSequencePointWithSpan foreachKeywordSequencePoint = new BoundSequencePointWithSpan(forEachSyntax, null, forEachSyntax.ForEachKeyword.Span);
result = new BoundStatementList(forEachSyntax, ReadOnlyArray<BoundStatement>.CreateFrom(foreachKeywordSequencePoint, result));
}
}
/// <summary>
/// Lower a foreach loop that will enumerate a single-dimensional array.
///
/// A[] a = x;
/// for (int p = 0; p < a.Length; p = p + 1) {
/// V v = (V)a[p];
/// // body
/// }
/// </summary>
/// <remarks>
/// We will follow Dev10 in diverging from the C# 4 spec by ignoring Array's
/// implementation of IEnumerable and just indexing into its elements.
///
/// NOTE: We're assuming that sequence points have already been generated.
/// Otherwise, lowering to for-loops would generated spurious ones.
/// </remarks>
private BoundStatement RewriteSingleDimensionalArrayForEachStatement(BoundForEachStatement node)
{
ForEachStatementSyntax forEachSyntax = (ForEachStatementSyntax)node.Syntax;
BoundExpression collectionExpression = GetUnconvertedCollectionExpression(node);
Debug.Assert(collectionExpression.Type.IsArray());
ArrayTypeSymbol arrayType = (ArrayTypeSymbol)collectionExpression.Type;
Debug.Assert(arrayType.Rank == 1);
TypeSymbol intType = compilation.GetSpecialType(SpecialType.System_Int32);
TypeSymbol boolType = compilation.GetSpecialType(SpecialType.System_Boolean);
BoundExpression rewrittenExpression = (BoundExpression)Visit(collectionExpression);
BoundStatement rewrittenBody = (BoundStatement)Visit(node.Body);
// A[] a
LocalSymbol arrayVar = new TempLocalSymbol(arrayType, RefKind.None, containingMethod);
// A[] a = /*node.Expression*/;
BoundStatement arrayVarDecl = MakeLocalDeclaration(forEachSyntax, arrayVar, rewrittenExpression);
AddForEachExpressionSequencePoint(forEachSyntax, ref arrayVarDecl);
// Reference to a.
BoundLocal boundArrayVar = MakeBoundLocal(forEachSyntax, arrayVar, arrayType);
// int p
LocalSymbol positionVar = new TempLocalSymbol(intType, RefKind.None, containingMethod);
// Reference to p.
BoundLocal boundPositionVar = MakeBoundLocal(forEachSyntax, positionVar, intType);
// int p = 0;
BoundStatement positionVarDecl = MakeLocalDeclaration(forEachSyntax, positionVar,
new BoundLiteral(forEachSyntax, ConstantValue.ConstantValueZero.Int32, intType));
// V v
LocalSymbol iterationVar = node.IterationVariable;
TypeSymbol iterationVarType = iterationVar.Type;
// (V)a[p]
BoundExpression iterationVarInitValue = SynthesizeConversion(
syntax: forEachSyntax,
operand: new BoundArrayAccess(
syntax: forEachSyntax,
expression: boundArrayVar,
indices: ReadOnlyArray<BoundExpression>.CreateFrom(boundPositionVar),
type: arrayType.ElementType),
conversion: node.ElementConversion,
type: iterationVarType);
// V v = (V)a[p];
BoundStatement iterationVariableDecl = MakeLocalDeclaration(forEachSyntax, iterationVar, iterationVarInitValue);
AddForEachIterationVariableSequencePoint(forEachSyntax, ref iterationVariableDecl);
BoundStatement initializer = new BoundStatementList(forEachSyntax,
statements: ReadOnlyArray<BoundStatement>.CreateFrom(arrayVarDecl, positionVarDecl));
// a.Length
BoundExpression arrayLength = new BoundArrayLength(
syntax: forEachSyntax,
expression: boundArrayVar,
type: intType);
// p < a.Length
BoundExpression exitCondition = new BoundBinaryOperator(
syntax: forEachSyntax,
operatorKind: BinaryOperatorKind.IntLessThan,
left: boundPositionVar,
right: arrayLength,
constantValueOpt: null,
methodOpt: null,
resultKind: LookupResultKind.Viable,
type: boolType);
// p = p + 1;
BoundStatement positionIncrement = MakePositionIncrement(forEachSyntax, boundPositionVar, intType);
// { V v = (V)a[p]; /* node.Body */ }
BoundStatement loopBody = new BoundBlock(forEachSyntax,
localsOpt: ReadOnlyArray<LocalSymbol>.CreateFrom(iterationVar),
statements: ReadOnlyArray<BoundStatement>.CreateFrom(iterationVariableDecl, rewrittenBody));
// for (A[] a = /*node.Expression*/, int p = 0; p < a.Length; p = p + 1) {
// V v = (V)a[p];
// /*node.Body*/
// }
BoundStatement result = RewriteForStatement(
syntax: node.Syntax,
locals: ReadOnlyArray<LocalSymbol>.CreateFrom(arrayVar, positionVar),
rewrittenInitializer: initializer,
rewrittenCondition: exitCondition,
conditionSyntax: forEachSyntax.InKeyword,
rewrittenIncrement: positionIncrement,
rewrittenBody: loopBody,
breakLabel: node.BreakLabel,
continueLabel: node.ContinueLabel, hasErrors: node.HasErrors);
AddForEachKeywordSequencePoint(forEachSyntax, ref result);
return result;
}
private BoundStatement RewriteMultiDimensionalArrayForEachStatement(BoundForEachStatement node)
{
ForEachStatementSyntax forEachSyntax = (ForEachStatementSyntax)node.Syntax;
BoundExpression collectionExpression = GetUnconvertedCollectionExpression(node);
Debug.Assert(collectionExpression.Type.IsArray());
ArrayTypeSymbol arrayType = (ArrayTypeSymbol)collectionExpression.Type;
int rank = arrayType.Rank;
Debug.Assert(rank > 1);
TypeSymbol intType = compilation.GetSpecialType(SpecialType.System_Int32);
TypeSymbol boolType = compilation.GetSpecialType(SpecialType.System_Boolean);
BoundExpression rewrittenExpression = (BoundExpression)Visit(collectionExpression);
BoundStatement rewrittenBody = (BoundStatement)Visit(node.Body);
// A[...] a
LocalSymbol arrayVar = new TempLocalSymbol(arrayType, RefKind.None, containingMethod);
// A[...] a = /*node.Expression*/;
BoundStatement arrayVarDecl = MakeLocalDeclaration(forEachSyntax, arrayVar, rewrittenExpression);
AddForEachExpressionSequencePoint(forEachSyntax, ref arrayVarDecl);
// Reference to a.
BoundLocal boundArrayVar = MakeBoundLocal(forEachSyntax, arrayVar, arrayType);
// int p_0, p_1, ...
LocalSymbol[] positionVar = new LocalSymbol[rank];
BoundLocal[] boundPositionVar = new BoundLocal[rank];
for (int dimension = 0; dimension < rank; dimension++)
{
positionVar[dimension] = new TempLocalSymbol(intType, RefKind.None, containingMethod);
boundPositionVar[dimension] = MakeBoundLocal(forEachSyntax, positionVar[dimension], intType);
}
// V v
LocalSymbol iterationVar = node.IterationVariable;
TypeSymbol iterationVarType = iterationVar.Type;
// (V)a[p_0, p_1, ...]
BoundExpression iterationVarInitValue = SynthesizeConversion(
syntax: forEachSyntax,
operand: new BoundArrayAccess(forEachSyntax,
expression: boundArrayVar,
indices: ReadOnlyArray<BoundExpression>.CreateFrom((BoundExpression[])boundPositionVar),
type: arrayType.ElementType),
conversion: node.ElementConversion,
type: iterationVarType);
// V v = (V)a[p_0, p_1, ...];
BoundStatement iterationVarDecl = MakeLocalDeclaration(forEachSyntax, iterationVar, iterationVarInitValue);
AddForEachIterationVariableSequencePoint(forEachSyntax, ref iterationVarDecl);
// { V v = (V)a[p_0, p_1, ...]; /* node.Body */ }
BoundStatement innermostLoopBody = new BoundBlock(forEachSyntax,
localsOpt: ReadOnlyArray<LocalSymbol>.CreateFrom(iterationVar),
statements: ReadOnlyArray<BoundStatement>.CreateFrom(iterationVarDecl, rewrittenBody));
// Values we'll use every iteration
MethodSymbol getLowerBoundMethod = (MethodSymbol)this.compilation.GetSpecialTypeMember(SpecialMember.System_Array__GetLowerBound);
MethodSymbol getUpperBoundMethod = (MethodSymbol)this.compilation.GetSpecialTypeMember(SpecialMember.System_Array__GetUpperBound);
// work from most-nested to least-nested
// for (A[...] a = /*node.Expression*/; int p_0 = a.GetLowerBound(0); p_0 <= a.GetUpperBound(0); p_0 = p_0 + 1)
// for (int p_1 = a.GetLowerBound(0); p_1 <= a.GetUpperBound(0); p_1 = p_1 + 1)
// ...
// { V v = (V)a[p_0, p_1, ...]; /* node.Body */ }
BoundStatement forLoop = null;
for (int dimension = rank - 1; dimension >= 0; dimension--)
{
ReadOnlyArray<BoundExpression> dimensionArgument = ReadOnlyArray<BoundExpression>.CreateFrom(
new BoundLiteral(forEachSyntax,
constantValueOpt: ConstantValue.Create(dimension, ConstantValueTypeDiscriminator.Int32),
type: intType));
// a.GetLowerBound(/*dimension*/)
BoundExpression currentDimensionLowerBound = BoundCall.Synthesized(forEachSyntax, boundArrayVar, getLowerBoundMethod, dimensionArgument);
// a.GetUpperBound(/*dimension*/) //CONSIDER: dev10 creates a temp for each dimension's upper bound
BoundExpression currentDimensionUpperBound = BoundCall.Synthesized(forEachSyntax, boundArrayVar, getUpperBoundMethod, dimensionArgument);
// int p_/*dimension*/ = a.GetLowerBound(/*dimension*/);
BoundStatement positionVarDecl = MakeLocalDeclaration(forEachSyntax, positionVar[dimension], currentDimensionLowerBound);
ReadOnlyArray<LocalSymbol> locals;
BoundStatement initializer;
GeneratedLabelSymbol breakLabel;
if (dimension == 0)
{
// outermost for-loop
locals = ReadOnlyArray<LocalSymbol>.CreateFrom(arrayVar, positionVar[dimension]);
initializer = new BoundStatementList(forEachSyntax,
statements: ReadOnlyArray<BoundStatement>.CreateFrom(arrayVarDecl, positionVarDecl));
breakLabel = node.BreakLabel; // i.e. the one that break statements will jump to
}
else
{
locals = ReadOnlyArray<LocalSymbol>.CreateFrom(positionVar[dimension]);
initializer = positionVarDecl;
breakLabel = new GeneratedLabelSymbol("break"); // Should not affect emitted code since unused
}
// p_/*dimension*/ <= a.GetUpperBound(/*dimension*/) //NB: OrEqual
BoundExpression exitCondition = new BoundBinaryOperator(
syntax: forEachSyntax,
operatorKind: BinaryOperatorKind.IntLessThanOrEqual,
left: boundPositionVar[dimension],
right: currentDimensionUpperBound,
constantValueOpt: null,
methodOpt: null,
resultKind: LookupResultKind.Viable,
type: boolType);
// p_/*dimension*/ = p_/*dimension*/ + 1;
BoundStatement positionIncrement = MakePositionIncrement(forEachSyntax, boundPositionVar[dimension], intType);
BoundStatement body;
GeneratedLabelSymbol continueLabel;
if(forLoop == null)
{
// innermost for-loop
body = innermostLoopBody;
continueLabel = node.ContinueLabel; //i.e. the one continue statements will actually jump to
}
else
{
body = forLoop;
continueLabel = new GeneratedLabelSymbol("continue"); // Should not affect emitted code since unused
}
forLoop = RewriteForStatement(
node.Syntax,
locals,
initializer,
exitCondition,
forEachSyntax.InKeyword,
positionIncrement,
body,
breakLabel,
continueLabel,
node.HasErrors);
}
Debug.Assert(forLoop != null);
AddForEachExpressionSequencePoint(forEachSyntax, ref forLoop);
return forLoop;
}
/// <summary>
/// Lower a foreach loop that will enumerate the characters of a string.
///
/// string s = x;
/// for (int p = 0; p < s.Length; p = p + 1) {
/// V v = (V)s.Chars[p];
/// // body
/// }
/// </summary>
/// <remarks>
/// We will follow Dev10 in diverging from the C# 4 spec by ignoring string's
/// implementation of IEnumerable and just indexing into its characters.
///
/// NOTE: We're assuming that sequence points have already been generated.
/// Otherwise, lowering to for-loops would generated spurious ones.
/// </remarks>
private BoundStatement RewriteStringForEachStatement(BoundForEachStatement node)
{
ForEachStatementSyntax forEachSyntax = (ForEachStatementSyntax)node.Syntax;
BoundExpression collectionExpression = GetUnconvertedCollectionExpression(node);
TypeSymbol stringType = collectionExpression.Type;
Debug.Assert(stringType.SpecialType == SpecialType.System_String);
TypeSymbol intType = compilation.GetSpecialType(SpecialType.System_Int32);
TypeSymbol boolType = compilation.GetSpecialType(SpecialType.System_Boolean);
BoundExpression rewrittenExpression = (BoundExpression)Visit(collectionExpression);
BoundStatement rewrittenBody = (BoundStatement)Visit(node.Body);
// string s;
LocalSymbol stringVar = new TempLocalSymbol(stringType, RefKind.None, containingMethod);
// int p;
LocalSymbol positionVar = new TempLocalSymbol(intType, RefKind.None, containingMethod);
// Reference to s.
BoundLocal boundStringVar = MakeBoundLocal(forEachSyntax, stringVar, stringType);
// Reference to p.
BoundLocal boundPositionVar = MakeBoundLocal(forEachSyntax, positionVar, intType);
// string s = /*expr*/;
BoundStatement stringVarDecl = MakeLocalDeclaration(forEachSyntax, stringVar, rewrittenExpression);
AddForEachExpressionSequencePoint(forEachSyntax, ref stringVarDecl);
// int p = 0;
BoundStatement positionVariableDecl = MakeLocalDeclaration(forEachSyntax, positionVar,
new BoundLiteral(forEachSyntax, ConstantValue.ConstantValueZero.Int32, intType));
// string s = /*node.Expression*/; int p = 0;
BoundStatement initializer = new BoundStatementList(forEachSyntax,
statements: ReadOnlyArray<BoundStatement>.CreateFrom(stringVarDecl, positionVariableDecl));
BoundExpression stringLength = BoundCall.Synthesized(
syntax: forEachSyntax,
receiverOpt: boundStringVar,
method: (MethodSymbol)compilation.GetSpecialTypeMember(SpecialMember.System_String__Length),
arguments: ReadOnlyArray<BoundExpression>.Empty);
// p < s.Length
BoundExpression exitCondition = new BoundBinaryOperator(
syntax: forEachSyntax,
operatorKind: BinaryOperatorKind.IntLessThan,
left: boundPositionVar,
right: stringLength,
constantValueOpt: null,
methodOpt: null,
resultKind: LookupResultKind.Viable,
type: boolType);
// p = p + 1;
BoundStatement positionIncrement = MakePositionIncrement(forEachSyntax, boundPositionVar, intType);
LocalSymbol iterationVar = node.IterationVariable;
TypeSymbol iterationVarType = iterationVar.Type;
Debug.Assert(node.ElementConversion.Exists);
// (V)s.Chars[p]
BoundExpression iterationVarInitValue = SynthesizeConversion(
syntax: forEachSyntax,
operand: BoundCall.Synthesized(
syntax: forEachSyntax,
receiverOpt: boundStringVar,
method: (MethodSymbol)this.compilation.GetSpecialTypeMember(SpecialMember.System_String__Chars),
arguments: ReadOnlyArray<BoundExpression>.CreateFrom(boundPositionVar)),
conversion: node.ElementConversion,
type: iterationVarType);
// V v = (V)s.Chars[p];
BoundStatement iterationVarDecl = MakeLocalDeclaration(forEachSyntax, iterationVar, iterationVarInitValue);
AddForEachIterationVariableSequencePoint(forEachSyntax, ref iterationVarDecl);
// { V v = (V)s.Chars[p]; /*node.Body*/ }
BoundStatement loopBody = new BoundBlock(forEachSyntax,
localsOpt: ReadOnlyArray<LocalSymbol>.CreateFrom(iterationVar),
statements: ReadOnlyArray<BoundStatement>.CreateFrom(iterationVarDecl, rewrittenBody));
// for (string s = /*node.Expression*/, int p = 0; p < s.Length; p = p + 1) {
// V v = (V)s.Chars[p];
// /*node.Body*/
// }
BoundStatement result = RewriteForStatement(
syntax: forEachSyntax,
locals: ReadOnlyArray<LocalSymbol>.CreateFrom(stringVar, positionVar),
rewrittenInitializer: initializer,
rewrittenCondition: exitCondition,
conditionSyntax: forEachSyntax.InKeyword,
rewrittenIncrement: positionIncrement,
rewrittenBody: loopBody,
breakLabel: node.BreakLabel,
continueLabel: node.ContinueLabel, hasErrors: node.HasErrors);
AddForEachKeywordSequencePoint(forEachSyntax, ref result);
return result;
}