private void Initialize(ElementInit elementInit)
        {
            if (elementInit == null) throw new ArgumentNullException("elementInit");

            AddMethod = new MethodInfoNode(Context, elementInit.AddMethod);
            Arguments = new ExpressionNodeList(Context, elementInit.Arguments);
        }

        protected override ElementInit VisitElementInit(ElementInit node)
        {
            var args = Visit(node.Arguments);
            foreach(var arg in args)
                AddParameter(arg);

            return null;
        }

 void ElementInit(ElementInit elementInit)
 {
     indent++;
     Write("Arguments:");
     foreach (var argument in elementInit.Arguments) {
         Expression(argument);
     }
     indent--;
 }

 public EditableElementInit(ElementInit elmInit)
     : this()
 {
     AddMethod = elmInit.AddMethod;
     foreach (Expression ex in elmInit.Arguments)
     {
         Arguments.Add(EditableExpression.Create(ex));
     }
 }

        private ElementInit[] GetInitializers(MethodInfo invoke, out ParameterExpression[] parameters)
        {
            ParameterInfo[] parameterInfos = invoke.GetParameters();
            var initializers = new ElementInit[parameterInfos.Length];
            parameters = new ParameterExpression[parameterInfos.Length];
            for (var i = 0; i < parameterInfos.Length; i++)
            {
                Expression dictionaryValue;
                Expression dictionaryKey;
                ParameterExpression parameter;

                BuildInitializer(out dictionaryValue, out dictionaryKey, out parameter, parameterInfos[i]);
                parameters[i] = parameter;
                initializers[i] = Expression.ElementInit(Tokens.DictionaryAdd, new[] { dictionaryKey, dictionaryValue });
            }
            return initializers;
        }

 /// <summary>
 /// Visits an ElementInit node.
 /// </summary>
 /// <param name="node">The ElementInit node.</param>
 /// <returns>The ElementInit node.</returns>
 protected override ElementInit VisitElementInit(ElementInit node)
 {
     throw new NotImplementedException();
 }

 private static ElementInit VisitElementInit(ElementInit node)
 {
     throw new NotImplementedException();
 }

		protected virtual ElementInit VisitElementInitializer (ElementInit initializer)
		{
			Expression[] args;
			if (VisitExpressionList (initializer.Arguments, out args))
				return Expression.ElementInit (initializer.AddMethod, args);

			return initializer;
		}

 /// <summary>
 /// ElementInit visit method
 /// </summary>
 /// <param name="initializer">The ElementInit expression to visit</param>
 /// <returns>The visited ElementInit expression </returns>
 internal override ElementInit VisitElementInitializer(ElementInit initializer)
 {
     this.VisitExpressionList(initializer.Arguments);
     return initializer;
 }

        /// <summary>
        /// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection. 
        /// </summary>
        /// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param>
        /// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection. </param>
        /// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param>
        /// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns>
        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable<Expression> initializers)
        {
            if (addMethod == null)
            {
                return ListInit(newExpression, initializers);
            }
            ContractUtils.RequiresNotNull(newExpression, "newExpression");
            ContractUtils.RequiresNotNull(initializers, "initializers");

            var initializerlist = initializers.ToReadOnly();
            if (initializerlist.Count == 0)
            {
                throw Error.ListInitializerWithZeroMembers();
            }
            ElementInit[] initList = new ElementInit[initializerlist.Count];
            for (int i = 0; i < initializerlist.Count; i++)
            {
                initList[i] = ElementInit(addMethod, initializerlist[i]);
            }
            return ListInit(newExpression, new TrueReadOnlyCollection<ElementInit>(initList));
        }

 public ElementInitNode(INodeFactory factory, ElementInit elementInit)
     : base(factory)
 {
     this.Initialize(elementInit);
 }

 /// <summary>
 /// Constructor with an <see cref="ElementInit"/> and an <see cref="ExpressionConverter"/>.
 /// </summary>
 /// <param name="elementInit">The original, not serializable <see cref="ElementInit"/>.</param>
 /// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param>
 public SerializableElementInit(ElementInit elementInit, ExpressionConverter expConverter)
 {
     Arguments = elementInit.Arguments.MakeSerializableCollection<SerializableExpression>(expConverter);
     AddMethod = elementInit.AddMethod;
 }

 /// <summary>
 /// ElementInit visit method
 /// </summary>
 /// <param name="initializer">The ElementInit expression to visit</param>
 /// <returns>The visited ElementInit expression </returns>
 internal override ElementInit VisitElementInitializer(ElementInit initializer)
 {
     throw new NotImplementedException();
 }

 protected virtual void VisitElementInitializer(ElementInit initializer)
 {
     this.VisitExpressionList(initializer.Arguments);
     throw new NotImplementedException ();
 }

 protected virtual void PVisitElementInitializer(ElementInit initializer)
 {
 }

 protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
 {
     var arguments = VisitExpressionList(initializer.Arguments);
     return arguments != initializer.Arguments ? Expression.ElementInit(initializer.AddMethod, arguments) : initializer;
 }

		protected override void VisitElementInitializer (ElementInit initializer)
		{
			object target = null;
			if (!initializer.AddMethod.IsStatic)
				target = Pop ();

			var arguments = VisitListExpressions (initializer.Arguments);
			InvokeMethod (initializer.AddMethod, target, arguments);

			if (!initializer.AddMethod.IsStatic)
				Push (target);
		}

 internal virtual ElementInit VisitElementInitializer(ElementInit initializer)
 {
     var arguments = VisitExpressionList(initializer.Arguments);
     if (arguments != initializer.Arguments)
     {
         return Expression.ElementInit(initializer.AddMethod, arguments);
     }
     return initializer;
 }

 public EditableElementInit(ElementInit elementInit)
 {
     AddMethod = elementInit.AddMethod;
     arguments = new EditableExpressionCollection<Expression>(elementInit.Arguments);
 }

    public virtual bool IsEvaluatableElementInit (ElementInit node)
    {
      ArgumentUtility.CheckNotNull ("node", node);

      return true;
    }