Example #1
0
        private Result RewriteIndexAssignment(BinaryExpression node, Stack stack)
        {
            var index = (IndexExpression)node.Left;

            var cr = new ChildRewriter(this, stack, 2 + index.ArgumentCount);

            cr.Add(index.Object);
            cr.AddArguments(index);
            cr.Add(node.Right);

            if (cr.Action == RewriteAction.SpillStack)
            {
                cr.MarkRefInstance(index.Object);
            }

            if (cr.Rewrite)
            {
                node = new AssignBinaryExpression
                       (
                    new IndexExpression
                    (
                        cr[0],    // Object
                        index.Indexer,
                        cr[1, -2] // arguments
                    ),
                    cr[-1]        // value
                       );
            }

            return(cr.Finish(node));
        }
            internal override Expression AsExpression(Expression target)
            {
                RequireNoValueProperty();
                RequireNotRefInstance(target);

                MemberExpression    member     = Expression.MakeMemberAccess(target, _binding.Member);
                ParameterExpression memberTemp = _spiller.MakeTemp(member.Type);

                Expression[] block = new Expression[_inits.Count + 2];
                block[0] = Expression.Assign(memberTemp, member);

                for (int i = 0; i < _inits.Count; i++)
                {
                    ChildRewriter cr  = _childRewriters[i];
                    Result        add = cr.Finish(Expression.Call(memberTemp, _inits[i].AddMethod, cr[0, -1]));
                    block[i + 1] = add.Node;
                }

                // We need to copy back value types
                if (memberTemp.Type.GetTypeInfo().IsValueType)
                {
                    block[_inits.Count + 1] = Expression.Block(
                        typeof(void),
                        Expression.Assign(Expression.MakeMemberAccess(target, _binding.Member), memberTemp)
                        );
                }
                else
                {
                    block[_inits.Count + 1] = Utils.Empty();
                }
                return(MakeBlock(block));
            }
Example #3
0
        private Result RewriteBinaryExpression(Expression expr, Stack stack)
        {
            var node = (BinaryExpression)expr;

            var cr = new ChildRewriter(this, stack, 3);

            // Left expression executes on the stack as left by parent
            cr.Add(node.Left);
            // Right expression always has non-empty stack (left is on it)
            cr.Add(node.Right);
            // conversion is a lambda, stack state will be ignored
            cr.Add(node.Conversion);

            if (cr.Action == RewriteAction.SpillStack)
            {
                RequireNoRefArgs(node.Method);
            }

            return(cr.Finish
                   (
                       cr.Rewrite
                    ? BinaryExpression.Create
                       (
                           node.NodeType,
                           cr[0],
                           cr[1],
                           node.Type,
                           node.Method,
                           (LambdaExpression)cr[2]
                       )
                    : expr
                   ));
        }
Example #4
0
        private Result RewriteIndexExpression(Expression expr, Stack stack)
        {
            var node = (IndexExpression)expr;

            var cr = new ChildRewriter(this, stack, node.ArgumentCount + 1);

            // For instance methods, the instance executes on the
            // stack as is, but stays on the stack, making it non-empty.
            cr.Add(node.Object);
            cr.AddArguments(node);

            if (cr.Action == RewriteAction.SpillStack)
            {
                cr.MarkRefInstance(node.Object);
            }

            if (cr.Rewrite)
            {
                expr = new IndexExpression
                       (
                    cr[0],
                    node.Indexer,
                    cr[1, -1]
                       );
            }

            return(cr.Finish(expr));
        }
Example #5
0
        private Result RewriteNewArrayExpression(Expression expr, Stack stack)
        {
            var node = (NewArrayExpression)expr;

            if (node.NodeType == ExpressionType.NewArrayInit)
            {
                // In a case of array construction with element initialization
                // the element expressions are never emitted on an empty stack because
                // the array reference and the index are on the stack.
                stack = Stack.NonEmpty;
            }
            else
            {
                // In a case of NewArrayBounds we make no modifications to the stack
                // before emitting bounds expressions.
            }

            var cr = new ChildRewriter(this, stack, node.Expressions.Count);

            cr.Add(node.Expressions);

            if (cr.Rewrite)
            {
                expr = NewArrayExpression.Make(node.NodeType, node.Type, new TrueReadOnlyCollection <Expression>(cr[0, -1]));
            }

            return(cr.Finish(expr));
        }
            internal override MemberBinding AsBinding()
            {
                switch (_action)
                {
                case RewriteAction.None:
                    return(_binding);

                case RewriteAction.Copy:
                    ElementInit[] newInits = new ElementInit[_inits.Count];
                    for (int i = 0; i < _inits.Count; i++)
                    {
                        ChildRewriter cr = _childRewriters[i];
                        if (cr.Action == RewriteAction.None)
                        {
                            newInits[i] = _inits[i];
                        }
                        else
                        {
                            newInits[i] = Expression.ElementInit(_inits[i].AddMethod, cr[0, -1]);
                        }
                    }
                    return(Expression.ListBind(_binding.Member, new TrueReadOnlyCollection <ElementInit>(newInits)));
                }
                throw ContractUtils.Unreachable;
            }
Example #7
0
        private Result RewriteMethodCallExpression(Expression expr, Stack stack)
        {
            MethodCallExpression node = (MethodCallExpression)expr;

            var cr = new ChildRewriter(this, stack, node.ArgumentCount + 1);

            // For instance methods, the instance executes on the
            // stack as is, but stays on the stack, making it non-empty.
            cr.Add(node.Object);

            cr.AddArguments(node);

            if (cr.Action == RewriteAction.SpillStack)
            {
                cr.MarkRefInstance(node.Object);
                cr.MarkRefArgs(node.Method, startIndex: 1);
            }

            if (cr.Rewrite)
            {
                if (node.Object != null)
                {
                    expr = new InstanceMethodCallExpressionN(node.Method, cr[0], cr[1, -1]);
                }
                else
                {
                    expr = new MethodCallExpressionN(node.Method, cr[1, -1]);
                }
            }

            return(cr.Finish(expr));
        }
        //RewriteIndexExpression
        private Result RewriteIndexExpression(Expression expr, Stack stack)
        {
            IndexExpression node = (IndexExpression)expr;

            ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);

            // For instance methods, the instance executes on the
            // stack as is, but stays on the stack, making it non-empty.
            cr.Add(node.Object);
            cr.Add(node.Arguments);

            if (cr.Action == RewriteAction.SpillStack)
            {
#if LINQ
                RequireNotRefInstance(node.Object);
#else
                MarkRefInstance(cr, node.Object);
#endif
            }

            if (cr.Rewrite)
            {
                expr = CreateIndexExpression(
                    cr[0],
                    node.Indexer,
                    cr[1, -1]
                    );
            }

            return(cr.Finish(expr));
        }
Example #9
0
            internal override MemberBinding AsBinding()
            {
                switch (Action)
                {
                case RewriteAction.None:
                    return(Binding);

                case RewriteAction.Copy:
                    int           count          = _initializers.Count;
                    ElementInit[] newInitializer = new ElementInit[count];
                    for (int i = 0; i < count; i++)
                    {
                        ChildRewriter cr = _childRewriters[i];
                        if (cr.Action == RewriteAction.None)
                        {
                            newInitializer[i] = _initializers[i];
                        }
                        else
                        {
                            newInitializer[i] = new ElementInit(_initializers[i].AddMethod, cr[0, -1]);
                        }
                    }
                    return(new MemberListBinding(Binding.Member, new TrueReadOnlyCollection <ElementInit>(newInitializer)));
                }
                throw ContractUtils.Unreachable;
            }
Example #10
0
        private Result RewriteMemberAssignment(BinaryExpression node, Stack stack)
        {
            var lvalue = (MemberExpression)node.Left;

            var cr = new ChildRewriter(this, stack, 2);

            // If there's an instance, it executes on the stack in current state
            // and rest is executed on non-empty stack.
            // Otherwise the stack is left unchanged.
            cr.Add(lvalue.Expression);

            cr.Add(node.Right);

            if (cr.Action == RewriteAction.SpillStack)
            {
                cr.MarkRefInstance(lvalue.Expression);
            }

            if (cr.Rewrite)
            {
                return(cr.Finish
                       (
                           new AssignBinaryExpression
                           (
                               MemberExpression.Make(cr[0], lvalue.Member),
                               cr[1]
                           )
                       ));
            }

            return(new Result(RewriteAction.None, node));
        }
            internal override Expression AsExpression(Expression target)
            {
                if (target.Type.IsValueType && _binding.Member is System.Reflection.PropertyInfo)
                {
                    throw Error.CannotAutoInitializeValueTypeElementThroughProperty(_binding.Member);
                }
                RequireNotRefInstance(target);

                MemberExpression    member     = Expression.MakeMemberAccess(target, _binding.Member);
                ParameterExpression memberTemp = _spiller.MakeTemp(member.Type);

                Expression[] block = new Expression[_inits.Count + 2];
                block[0] = Expression.Assign(memberTemp, member);

                for (int i = 0; i < _inits.Count; i++)
                {
                    ChildRewriter cr  = _childRewriters[i];
                    Result        add = cr.Finish(Expression.Call(memberTemp, _inits[i].AddMethod, cr[0, -1]));
                    block[i + 1] = add.Node;
                }

                // We need to copy back value types
                if (memberTemp.Type.IsValueType)
                {
                    block[_inits.Count + 1] = Expression.Block(
                        typeof(void),
                        Expression.Assign(Expression.MakeMemberAccess(target, _binding.Member), memberTemp)
                        );
                }
                else
                {
                    block[_inits.Count + 1] = Expression.Empty();
                }
                return(MakeBlock(block));
            }
Example #12
0
            internal override Expression AsExpression(Expression target)
            {
                RequireNoValueProperty();

                Expression member     = MemberExpression.Make(target, _binding.Member);
                Expression memberTemp = _spiller.MakeTemp(member.Type);

                int count = _inits.Count;

                Expression[] block = new Expression[count + 2];
                block[0] = new AssignBinaryExpression(memberTemp, member);

                for (int i = 0; i < count; i++)
                {
                    ChildRewriter cr  = _childRewriters[i];
                    Result        add = cr.Finish(new InstanceMethodCallExpressionN(_inits[i].AddMethod, memberTemp, cr[0, -1] !));
                    block[i + 1] = add.Node;
                }

                // We need to copy back value types
                if (memberTemp.Type.IsValueType)
                {
                    block[count + 1] = Expression.Block(
                        typeof(void),
                        new AssignBinaryExpression(MemberExpression.Make(target, _binding.Member), memberTemp)
                        );
                }
                else
                {
                    block[count + 1] = Utils.Empty;
                }

                return(MakeBlock(block));
            }
        // MethodCallExpression
        private Result RewriteMethodCallExpression(Expression expr, Stack stack)
        {
            MethodCallExpression node = (MethodCallExpression)expr;

            ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);

            // For instance methods, the instance executes on the
            // stack as is, but stays on the stack, making it non-empty.
            cr.Add(node.Object);

            cr.AddArguments(node);

            if (cr.Action == RewriteAction.SpillStack)
            {
#if LINQ
                RequireNotRefInstance(node.Object);
                RequireNoRefArgs(node.Method);
#else
                MarkRefInstance(cr, node.Object);
                MarkRefArgs(cr, node.Method, 1);
#endif
            }

            return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr));
        }
        private Result RewriteMemberExpression(Expression expr, Stack stack)
        {
            MemberExpression node = (MemberExpression)expr;

            ChildRewriter cr = new ChildRewriter(this, stack, 1);

            cr.Add(node.Expression);

            if (cr.Rewrite)
            {
                if (cr.Action == RewriteAction.SpillStack && node.Member is PropertyInfo)
                {
                    // Only need to validate propreties because reading a field
                    // is always side-effect free.
#if LINQ
                    RequireNotRefInstance(node.Expression);
#else
                    MarkRefInstance(cr, node.Expression);
#endif
                }

                expr = MemberExpressionStubs.Make(cr[0], node.Member);
            }

            return(cr.Finish(expr));
        }
        private Result RewriteIndexAssignment(BinaryExpression node, Stack stack)
        {
            IndexExpression index = (IndexExpression)node.Left;

            ChildRewriter cr = new ChildRewriter(this, stack, 2 + index.Arguments.Count);

            cr.Add(index.Object);
            cr.Add(index.Arguments);
            cr.Add(node.Right);

            if (cr.Action == RewriteAction.SpillStack)
            {
#if LINQ
                RequireNotRefInstance(index.Object);
#else
                MarkRefInstance(cr, index.Object);
#endif
            }

            if (cr.Rewrite)
            {
                node = CreateAssignBinaryExpression(
                    CreateIndexExpression(
                        cr[0],                              // Object
                        index.Indexer,
                        cr[1, -2]                           // arguments
                        ),
                    cr[-1]                                  // value
                    );
            }

            return(cr.Finish(node));
        }
Example #16
0
 private static void MarkRefInstance(ChildRewriter cr, Expression instance)
 {
     // Primitive value types are okay because they are all readonly,
     // but we can't rely on this for non-primitive types. For those
     // we have to spill the by ref local.
     if (instance != null && instance.Type.GetTypeInfo().IsValueType&& instance.Type.GetTypeCode() == TypeCode.Object)
     {
         cr.MarkByRef(0);
     }
 }
Example #17
0
        // NewExpression
        private Result RewriteNewExpression(Expression expr, Stack stack)
        {
            NewExpression node = (NewExpression)expr;

            // The first expression starts on a stack as provided by parent,
            // rest are definitely non-emtpy (which ChildRewriter guarantees)
            ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count);

            cr.Add(node.Arguments);

            return(cr.Finish(cr.Rewrite ? new NewExpression(node.Constructor, cr[0, -1], node.Members) : expr));
        }
Example #18
0
        // InvocationExpression
        private Result RewriteInvocationExpression(Expression expr, Stack stack)
        {
            InvocationExpression node = (InvocationExpression)expr;

            ChildRewriter cr;

#if LINQ // NB: Our compiler doesn't inline; this could still happen at a later stage in the LINQ compiler after lowering async lambdas to sync ones.
            // See if the lambda will be inlined
            LambdaExpression lambda = node.LambdaOperand();
            if (lambda != null)
            {
                // Arguments execute on current stack
                cr = new ChildRewriter(this, stack, node.Arguments.Count);
                cr.Add(node.Arguments);

                if (cr.Action == RewriteAction.SpillStack)
                {
                    RequireNoRefArgs(ExpressionStubs.GetInvokeMethod(node.Expression));
                }

                // Lambda body also executes on current stack
                var spiller = new StackSpiller(stack);
                lambda = lambda.Accept(spiller);

                if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None)
                {
                    node = node.Rewrite(lambda, cr[0, -1]);
                }

                Result result = cr.Finish(node);
                return(new Result(result.Action | spiller._lambdaRewrite, result.Node));
            }
#endif

            cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);

            // first argument starts on stack as provided
            cr.Add(node.Expression);

            // rest of arguments have non-empty stack (delegate instance on the stack)
            cr.Add(node.Arguments);

            if (cr.Action == RewriteAction.SpillStack)
            {
#if LINQ
                RequireNoRefArgs(ExpressionStubs.GetInvokeMethod(node.Expression));
#else
                MarkRefArgs(cr, ExpressionStubs.GetInvokeMethod(node.Expression), 1);
#endif
            }

            return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr));
        }
Example #19
0
        // MethodCallExpression
        // TODO: ref parameters!!!
        private Result RewriteMethodCallExpression(Expression expr, Stack stack)
        {
            MethodCallExpression node = (MethodCallExpression)expr;

            ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);

            // For instance methods, the instance executes on the
            // stack as is, but stays on the stack, making it non-empty.
            cr.Add(node.Object);

            cr.Add(node.Arguments);

            return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr));
        }
Example #20
0
        // InvocationExpression
        private Result RewriteInvocationExpression(Expression expr, Stack stack)
        {
            InvocationExpression node = (InvocationExpression)expr;

            // first argument starts on stack as provided
            ChildRewriter cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);

            cr.Add(node.Expression);

            // rest of arguments have non-empty stack (delegate instance on the stack)
            cr.Add(node.Arguments);

            return(cr.Finish(cr.Rewrite ? new InvocationExpression(cr[0], cr[1, -1], node.Type) : expr));
        }
        private Result RewriteAwaitExpression(Expression expr, Stack stack)
        {
            var node = (AwaitCSharpExpression)expr;

            ChildRewriter cr = new ChildRewriter(this, stack, 1);

            cr.Add(node.Operand);

            // NB: We always spill the stack for await, so unconditionally rewrite.

            var res = cr.Finish(node.Rewrite(cr[0], node.Info));

            return(new Result(RewriteAction.SpillStack, res.Node));
        }
Example #22
0
        private Result RewriteDynamicExpression(Expression expr, Stack stack)
        {
            var node = (IDynamicExpression)expr;

            // CallSite is on the stack
            ChildRewriter cr = new ChildRewriter(this, Stack.NonEmpty, node.ArgumentCount);

            cr.AddArguments(node);
            if (cr.Action == RewriteAction.SpillStack)
            {
                RequireNoRefArgs(node.DelegateType.GetMethod("Invoke"));
            }
            return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0, -1]) : expr));
        }
        private Result RewriteAwaitExpression(Expression expr, Stack stack)
        {
            var node = (AwaitCSharpExpression)expr;

            ChildRewriter cr = new ChildRewriter(this, stack, 1);

            cr.Add(node.Operand);

            // NB: We always spill the stack for await, so unconditionally rewrite.

            var res = cr.Finish(node.Rewrite(cr[0]));

            return new Result(RewriteAction.SpillStack, res.Node);
        }
Example #24
0
 private static void MarkRefArgs(ChildRewriter cr, MethodBase method, int firstIndex)
 {
     if (method != null)
     {
         var parameters = method.GetParametersCached();
         for (int i = 0, j = firstIndex; i < parameters.Length; i++, j++)
         {
             var parameter = parameters[i];
             if (parameter.ParameterType.IsByRef)
             {
                 cr.MarkByRef(j);
             }
         }
     }
 }
Example #25
0
        private Result RewriteDynamicExpression(Expression expr, Stack stack)
        {
            var node = (DynamicExpression)expr;

            // CallSite is on the stack
            IArgumentProvider argNode = (IArgumentProvider)node;
            int           argCount    = argNode.ArgumentCount;
            ChildRewriter cr          = new ChildRewriter(this, Stack.NonEmpty, argCount);

            for (int i = 0; i < argCount; i++)
            {
                cr.Add(argNode.GetArgument(i));
            }
            return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0, -1]) : expr));
        }
Example #26
0
        private Result RewriteInvocationExpression(Expression expr, Stack stack)
        {
            var node = (InvocationExpression)expr;

            ChildRewriter cr;

            // See if the lambda will be inlined.
            LambdaExpression lambda = node.LambdaOperand;

            if (lambda != null)
            {
                // Arguments execute on current stack.
                cr = new ChildRewriter(this, stack, node.ArgumentCount);
                cr.AddArguments(node);

                if (cr.Action == RewriteAction.SpillStack)
                {
                    cr.MarkRefArgs(Expression.GetInvokeMethod(node.Expression), startIndex: 0);
                }

                // Lambda body also executes on current stack.
                var spiller = new StackSpiller(stack);
                lambda = lambda.Accept(spiller);

                if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None)
                {
                    node = new InvocationExpressionN(lambda, cr[0, -1], node.Type);
                }

                Result result = cr.Finish(node);
                return(new Result(result.Action | spiller._lambdaRewrite, result.Node));
            }

            cr = new ChildRewriter(this, stack, node.ArgumentCount + 1);

            // First argument starts on stack as provided.
            cr.Add(node.Expression);

            // Rest of arguments have non-empty stack (the delegate instance is on the stack).
            cr.AddArguments(node);

            if (cr.Action == RewriteAction.SpillStack)
            {
                cr.MarkRefArgs(Expression.GetInvokeMethod(node.Expression), startIndex: 1);
            }

            return(cr.Finish(cr.Rewrite ? new InvocationExpressionN(cr[0], cr[1, -1], node.Type) : expr));
        }
Example #27
0
        // InvocationExpression
        private Result RewriteInvocationExpression(Expression expr, Stack stack)
        {
            InvocationExpression node = (InvocationExpression)expr;

            ChildRewriter cr;

            // See if the lambda will be inlined
            LambdaExpression lambda = node.LambdaOperand;

            if (lambda != null)
            {
                // Arguments execute on current stack
                cr = new ChildRewriter(this, stack, node.Arguments.Count);
                cr.Add(node.Arguments);

                if (cr.Action == RewriteAction.SpillStack)
                {
                    RequireNoRefArgs(Expression.GetInvokeMethod(node.Expression));
                }

                // Lambda body also executes on current stack
                var spiller = new StackSpiller(stack);
                lambda = lambda.Accept(spiller);

                if (cr.Rewrite || spiller._lambdaRewrite != RewriteAction.None)
                {
                    node = node.Rewrite(lambda, cr[0, -1]);
                }

                Result result = cr.Finish(node);
                return(new Result(result.Action | spiller._lambdaRewrite, result.Node));
            }

            cr = new ChildRewriter(this, stack, node.Arguments.Count + 1);

            // first argument starts on stack as provided
            cr.Add(node.Expression);

            // rest of arguments have non-empty stack (delegate instance on the stack)
            cr.Add(node.Arguments);

            if (cr.Action == RewriteAction.SpillStack)
            {
                RequireNoRefArgs(Expression.GetInvokeMethod(node.Expression));
            }

            return(cr.Finish(cr.Rewrite ? node.Rewrite(cr[0], cr[1, -1]) : expr));
        }
            internal ListBindingRewriter(MemberListBinding memberBinding, StackSpiller stackSpiller, Stack stack) :
                base(memberBinding, stackSpiller)
            {
                _inits = memberBinding.Initializers;

                _childRewriters = new ChildRewriter[_inits.Count];
                for (var i = 0; i < _inits.Count; i++)
                {
                    var init = _inits[i];

                    var cr = new ChildRewriter(stackSpiller, stack, init.Arguments.Count);
                    cr.Add(init.Arguments);

                    RewriteAction     |= cr.Action;
                    _childRewriters[i] = cr;
                }
            }
            internal ListBindingRewriter(MemberListBinding binding, StackSpiller spiller, Stack stack) :
                base(binding, spiller)
            {
                _inits = binding.Initializers;

                _childRewriters = new ChildRewriter[_inits.Count];
                for (int i = 0; i < _inits.Count; i++)
                {
                    ElementInit init = _inits[i];

                    ChildRewriter cr = new ChildRewriter(spiller, stack, init.Arguments.Count);
                    cr.Add(init.Arguments);

                    _action           |= cr.Action;
                    _childRewriters[i] = cr;
                }
            }
Example #30
0
        private Result RewriteNewExpression(Expression expr, Stack stack)
        {
            var node = (NewExpression)expr;

            // The first expression starts on a stack as provided by parent,
            // rest are definitely non-empty (which ChildRewriter guarantees).
            var cr = new ChildRewriter(this, stack, node.ArgumentCount);

            cr.AddArguments(node);

            if (cr.Action == RewriteAction.SpillStack)
            {
                cr.MarkRefArgs(node.Constructor, startIndex: 0);
            }

            return(cr.Finish(cr.Rewrite ? new NewExpression(node.Constructor, cr[0, -1], node.Members) : expr));
        }
Example #31
0
            internal ListBindingRewriter(MemberListBinding binding, StackSpiller spiller, Stack stack) :
                base(binding, spiller)
            {
                _initializers = binding.Initializers;

                var count = _initializers.Count;

                _childRewriters = new ChildRewriter[count];

                for (var i = 0; i < count; i++)
                {
                    var init = _initializers[i];

                    var cr = new ChildRewriter(spiller, stack, init.Arguments.Count);
                    cr.Add(init.Arguments);

                    Action            |= cr.Action;
                    _childRewriters[i] = cr;
                }
            }
            internal ListBindingRewriter(MemberListBinding binding, StackSpiller spiller, Stack stack) :
                base(binding, spiller)
            {
                _inits = binding.Initializers;

                _childRewriters = new ChildRewriter[_inits.Count];
                for (int i = 0; i < _inits.Count; i++)
                {
                    ElementInit init = _inits[i];

                    ChildRewriter cr = new ChildRewriter(spiller, stack, init.Arguments.Count);
                    cr.Add(init.Arguments);

                    _action |= cr.Action;
                    _childRewriters[i] = cr;
                }
            }