public override BoundNode VisitArrayInitialization(BoundArrayInitialization node)
{
BoundSpillSequenceBuilder builder = null;
var initializers = this.VisitExpressionList(ref builder, node.Initializers);
return(UpdateExpression(builder, node.Update(initializers)));
}
private int TryGetRawDataForArrayInit(BoundArrayInitialization initializer, out ImmutableArray<byte> data)
{
data = default;
if (initializer == null)
{
return -1;
}
var initializers = initializer.Initializers;
if (initializers.Any(init => init.ConstantValue == null))
{
return -1;
}
var elementCount = initializers.Length;
if (elementCount == 0)
{
data = ImmutableArray<byte>.Empty;
return 0;
}
var writer = new BlobBuilder(initializers.Length * 4);
foreach (var init in initializer.Initializers)
{
init.ConstantValue.Serialize(writer);
}
data = writer.ToImmutableArray();
return elementCount;
}
internal void Parse(BoundArrayInitialization boundArrayInitialization)
{
base.Parse(boundArrayInitialization);
foreach (var boundExpression in boundArrayInitialization.Initializers)
{
var item = Deserialize(boundExpression) as Expression;
Debug.Assert(item != null);
this.Initializers.Add(item);
}
}
private void EmitStackAllocInitializers(TypeSymbol type, BoundArrayInitialization inits)
{
Debug.Assert(type is PointerTypeSymbol || type is NamedTypeSymbol);
var elementType = type.TypeKind == TypeKind.Pointer
? ((PointerTypeSymbol)type).PointedAtType
: ((NamedTypeSymbol)type).TypeArgumentsNoUseSiteDiagnostics[0];
var initExprs = inits.Initializers;
var initializationStyle = ShouldEmitBlockInitializerForStackAlloc(elementType, initExprs);
if (initializationStyle == ArrayInitializerStyle.Element)
{
EmitElementStackAllocInitializers(elementType, initExprs, includeConstants: true);
}
else
{
ImmutableArray <byte> data = this.GetRawData(initExprs);
if (data.All(datum => datum == data[0]))
{
_builder.EmitStackAllocBlockInitializer(data, inits.Syntax, emitInitBlock: true, _diagnostics);
if (initializationStyle == ArrayInitializerStyle.Mixed)
{
EmitElementStackAllocInitializers(elementType, initExprs, includeConstants: false);
}
}
else if (elementType.SpecialType.SizeInBytes() == 1)
{
_builder.EmitStackAllocBlockInitializer(data, inits.Syntax, emitInitBlock: false, _diagnostics);
if (initializationStyle == ArrayInitializerStyle.Mixed)
{
EmitElementStackAllocInitializers(elementType, initExprs, includeConstants: false);
}
}
else
{
EmitElementStackAllocInitializers(elementType, initExprs, includeConstants: true);
}
}
}
/// <summary>
/// Entry point to the array initialization.
/// Assumes that we have newly created array on the stack.
///
/// inits could be an array of values for a single dimensional array
/// or an array (of array)+ of values for a multidimensional case
///
/// in either case it is expected that number of leaf values will match number
/// of elements in the array and nesting level should match the rank of the array.
/// </summary>
private void EmitArrayInitializers(ArrayTypeSymbol arrayType, BoundArrayInitialization inits)
{
var initExprs = inits.Initializers;
var initializationStyle = ShouldEmitBlockInitializer(arrayType.ElementType, initExprs);
if (initializationStyle == ArrayInitializerStyle.Element)
{
this.EmitElementInitializers(arrayType, initExprs, true);
}
else
{
ImmutableArray<byte> data = this.GetRawData(initExprs);
_builder.EmitArrayBlockInitializer(data, inits.Syntax, _diagnostics);
if (initializationStyle == ArrayInitializerStyle.Mixed)
{
EmitElementInitializers(arrayType, initExprs, false);
}
}
}
private void EmitArrayInitializers(ArrayTypeSymbol arrayType, BoundArrayInitialization inits)
{
var initExprs = inits.Initializers;
var initializationStyle = ShouldEmitBlockInitializer(arrayType.ElementType, initExprs);
if (initializationStyle == ArrayInitializerStyle.Element)
{
this.EmitElementInitializers(arrayType, initExprs, true);
}
else
{
ImmutableArray<byte> data = this.GetRawData(initExprs);
_builder.EmitArrayBlockInitializer(data, inits.Syntax, _diagnostics);
if (initializationStyle == ArrayInitializerStyle.Mixed)
{
EmitElementInitializers(arrayType, initExprs, false);
}
}
}
public override BoundNode VisitArrayInitialization(BoundArrayInitialization node)
{
// nontrivial construct - may use dups, metadata blob helpers etc..
EnsureOnlyEvalStack();
var initializers = node.Initializers;
ArrayBuilder<BoundExpression> rewrittenInitializers = null;
if (!initializers.IsDefault)
{
for (int i = 0; i < initializers.Length; i++)
{
// array itself will be pushed on the stack here.
EnsureOnlyEvalStack();
var initializer = initializers[i];
var rewrittenInitializer = this.VisitExpression(initializer, ExprContext.Value);
if (rewrittenInitializers == null && rewrittenInitializer != initializer)
{
rewrittenInitializers = ArrayBuilder<BoundExpression>.GetInstance();
rewrittenInitializers.AddRange(initializers, i);
}
if (rewrittenInitializers != null)
{
rewrittenInitializers.Add(rewrittenInitializer);
}
}
}
return node.Update(rewrittenInitializers != null ?
rewrittenInitializers.ToImmutableAndFree() :
initializers);
}
internal static ImmutableArray <BoundExpression> GetChildInitializers(BoundArrayInitialization arrayInitializer)
{
return(arrayInitializer?.Initializers ?? ImmutableArray <BoundExpression> .Empty);
}
