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); }