RewriteListInitExpression()

Result System.Linq.Expressions.Compiler.StackSpiller.RewriteListInitExpression ( Expression expr, Stack stack )

inlineprivate

Definition at line 864 of file StackSpiller.cs.

    {
        ListInitExpression listInitExpression = (ListInitExpression)expr;
        Result result = RewriteExpression(listInitExpression.NewExpression, stack);
        Expression node = result.Node;
        RewriteAction rewriteAction = result.Action;
        ReadOnlyCollection<ElementInit> initializers = listInitExpression.Initializers;
        int count = initializers.Count;
        ChildRewriter[] array = new ChildRewriter[count];
        for (int i = 0; i < count; i++)
        {
            ElementInit elementInit = initializers[i];
            ChildRewriter childRewriter = new ChildRewriter(this, Stack.NonEmpty, elementInit.Arguments.Count);
            childRewriter.Add(elementInit.Arguments);
            rewriteAction |= childRewriter.Action;
            array[i] = childRewriter;
        }
        switch (rewriteAction)
        {
        case RewriteAction.Copy:
        {
            ElementInit[] array2 = new ElementInit[count];
            for (int k = 0; k < count; k++)
            {
                ChildRewriter childRewriter3 = array[k];
                if (childRewriter3.Action == RewriteAction.None)
                {
                    array2[k] = initializers[k];
                }
                else
                {
                    array2[k] = new ElementInit(initializers[k].AddMethod, new TrueReadOnlyCollection<Expression>(childRewriter3[0, -1]));
                }
            }
            expr = new ListInitExpression((NewExpression)node, new TrueReadOnlyCollection<ElementInit>(array2));
            break;
        }
        case RewriteAction.SpillStack:
        {
            bool flag = IsRefInstance(listInitExpression.NewExpression);
            System.Collections.Generic.ArrayBuilder<Expression> expressions = new System.Collections.Generic.ArrayBuilder<Expression>(count + 2 + (flag ? 1 : 0));
            ParameterExpression parameterExpression = MakeTemp(node.Type);
            expressions.UncheckedAdd(new AssignBinaryExpression(parameterExpression, node));
            ParameterExpression parameterExpression2 = parameterExpression;
            if (flag)
            {
                parameterExpression2 = MakeTemp(parameterExpression.Type.MakeByRefType());
                expressions.UncheckedAdd(new ByRefAssignBinaryExpression(parameterExpression2, parameterExpression));
            }
            for (int j = 0; j < count; j++)
            {
                ChildRewriter childRewriter2 = array[j];
                expressions.UncheckedAdd(childRewriter2.Finish(new InstanceMethodCallExpressionN(initializers[j].AddMethod, parameterExpression2, childRewriter2[0, -1])).Node);
            }
            expressions.UncheckedAdd(parameterExpression);
            expr = MakeBlock(expressions);
            break;
        }
        default:
            throw ContractUtils.Unreachable;
        case RewriteAction.None:
            break;
        }
        return new Result(rewriteAction, expr);
    }

References System.Linq.Expressions.Compiler.StackSpiller.Result.Action, System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.array, System.Linq.count, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Linq.Expressions.Compiler.StackSpiller.IsRefInstance(), System.Linq.Expressions.Compiler.StackSpiller.MakeBlock(), System.Linq.Expressions.Compiler.StackSpiller.MakeTemp(), System.Linq.Expressions.Compiler.StackSpiller.Result.Node, System.Linq.Expressions.Compiler.StackSpiller.RewriteExpression(), and System.Dynamic.Utils.ContractUtils.Unreachable.

Referenced by System.Linq.Expressions.Compiler.StackSpiller.RewriteExpression().