protected internal ArrayCreation(NRefactory.ArrayCreateExpression arrayCreateExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor)
{
_arrayCreateExpression = arrayCreateExpression;
_isJaggeedArray = IsJaggedArray();
_isVector = IsVector();
InternalType = GetArrayType();
if (InternalType.GetArrayRank() == 1 && !_isJaggeedArray)
{
if (TryGetOneDimensionalArrayBounds())
{
BuildEmptyOneDimensionalArray();
}
else
{
BuildOneDimensionalArray();
}
}
else
{
if (TryGetBounds())
{
BuildEmptyMultiDimensionalArray();
}
else
{
BuildMultiDimensionalArrayAccess();
}
}
}
private void BuildMultiDimensionalArrayAccess()
{
Func <INode, IEnumerable <int> > getBounds = null;
getBounds = (INode node) => {
List <int> bounds = new List <int>();
int nodeCount = node.Nodes.Count;
if (nodeCount != 0)
{
bounds.Add(nodeCount);
bounds.AddRange(getBounds(node.Nodes[0]));
}
return(bounds);
};
var root = new MultiDimensionalArrayIndexes()
{
Rank = InternalType.GetArrayRank()
};
var indexExpressions = new List <Tuple <Expression, IEnumerable <Expression> > >();
BuildIndexes(_arrayCreateExpression.Initializer, root);
root.Nodes.Cast <IChildNode>().ForEach((node, i) => {
var indexes = new List <int>()
{
i
};
if (root.Rank > 1)
{
BuildArrayAccess(node, indexes, indexExpressions);
}
else
{
indexExpressions.Add(CreateIndexExpression(node as ILeafNode <Expression>, indexes));
}
});
var arrayBounds = getBounds(root).Select(i => Expression.Constant(i, TypeSystem.Int));
var arrayCreation = Expression.NewArrayBounds(_baseType, arrayBounds);
var array = Expression.Parameter(InternalType);
var arrayInitializers = indexExpressions.Select(tuple => {
return(Expression.Assign(
Expression.ArrayAccess(array, tuple.Item2),
tuple.Item1));
});
_newArrayCreation = Expression.Invoke(
Expression.Lambda(
Expression.GetFuncType(new[] { InternalType }),
Expression.Block(new[] { array },
new Expression[] {
Expression.Assign(array, arrayCreation)
}
.Concat(arrayInitializers)
.Concat(array))));
}