public override BoundNode VisitArrayCreation(BoundArrayCreation node)
{
var arrayType = (ArrayTypeSymbol)node.Type;
if (_inExpressionLambda && node.InitializerOpt != null && !arrayType.IsSZArray)
{
Error(ErrorCode.ERR_ExpressionTreeContainsMultiDimensionalArrayInitializer, node);
}
return base.VisitArrayCreation(node);
}
private TypedConstant VisitArrayCreation(BoundArrayCreation node, DiagnosticBag diagnostics, ref bool attrHasErrors, bool curArgumentHasErrors)
{
ImmutableArray<BoundExpression> bounds = node.Bounds;
int boundsCount = bounds.Length;
if (boundsCount > 1)
{
return CreateTypedConstant(node, TypedConstantKind.Error, diagnostics, ref attrHasErrors, curArgumentHasErrors);
}
var type = (ArrayTypeSymbol)node.Type;
var typedConstantKind = type.GetAttributeParameterTypedConstantKind(_binder.Compilation);
ImmutableArray<TypedConstant> initializer;
if (node.InitializerOpt == null)
{
if (boundsCount == 0)
{
initializer = ImmutableArray<TypedConstant>.Empty;
}
else
{
if (bounds[0].IsDefaultValue())
{
initializer = ImmutableArray<TypedConstant>.Empty;
}
else
{
// error: non-constant array creation
initializer = ImmutableArray.Create(CreateTypedConstant(node, TypedConstantKind.Error, diagnostics, ref attrHasErrors, curArgumentHasErrors));
}
}
}
else
{
initializer = VisitArguments(node.InitializerOpt.Initializers, diagnostics, ref attrHasErrors, curArgumentHasErrors);
}
return CreateTypedConstant(node, typedConstantKind, diagnostics, ref attrHasErrors, curArgumentHasErrors, arrayValue: initializer);
}
private BoundExpression VisitArrayCreation(BoundArrayCreation node)
{
var arrayType = (ArrayTypeSymbol)node.Type;
var boundType = _bound.Typeof(arrayType.ElementType);
if (node.InitializerOpt != null)
{
if (arrayType.IsSZArray)
{
return ExprFactory("NewArrayInit", boundType, Expressions(node.InitializerOpt.Initializers));
}
else
{
// error should have been reported earlier
// Bound.Diagnostics.Add(ErrorCode.ERR_ExpressionTreeContainsMultiDimensionalArrayInitializer, node.Syntax.Location);
return new BoundBadExpression(node.Syntax, default(LookupResultKind), ImmutableArray<Symbol>.Empty, ImmutableArray.Create<BoundNode>(node), ExpressionType);
}
}
else
{
return ExprFactory("NewArrayBounds", boundType, Expressions(node.Bounds));
}
}
public override BoundNode VisitArrayCreation(BoundArrayCreation node)
{
BoundSpillSequence2 ss = null;
var init = (BoundArrayInitialization)VisitExpression(ref ss, node.InitializerOpt);
ImmutableArray<BoundExpression> bounds;
if (ss == null)
{
bounds = VisitExpressionList(ref ss, node.Bounds);
}
else
{
// spill bounds expressions if initializers contain await
var ss2 = new BoundSpillSequence2();
bounds = VisitExpressionList(ref ss2, node.Bounds, forceSpill: true);
ss2.IncludeSequence(ss);
ss = ss2;
}
return UpdateExpression(ss, node.Update(bounds, init, node.Type));
}
public override BoundNode VisitArrayCreation(BoundArrayCreation node)
{
ReadOnlyArray<BoundExpression> bounds = this.VisitList(node.Bounds);
BoundArrayInitialization visitedInitializer = (BoundArrayInitialization)this.Visit(node.InitializerOpt);
TypeSymbol type = this.VisitType(node.Type);
if (!RequiresSpill(bounds) && (visitedInitializer == null || !RequiresSpill(visitedInitializer.Initializers)))
{
return node.Update(bounds, visitedInitializer, type);
}
var spillBuilder = new SpillBuilder();
ReadOnlyArray<BoundExpression> newBounds = SpillExpressionList(spillBuilder, bounds);
BoundArrayInitialization newInitializerOpt = (visitedInitializer == null) ? visitedInitializer :
visitedInitializer.Update(SpillExpressionList(spillBuilder, visitedInitializer.Initializers));
BoundArrayCreation newArrayCreation = node.Update(newBounds, newInitializerOpt, type);
return spillBuilder.BuildSequenceAndFree(F, newArrayCreation);
}