protected ListInitExpression UpdateListInit(ListInitExpression init, NewExpression nex, IEnumerable<ElementInit> initializers)
 {
     if (nex != init.NewExpression || initializers != init.Initializers) {
         return Expression.ListInit(nex, initializers);
     }
     return init;
 }

 protected static ListInitExpression UpdateListInit(ListInitExpression node, NewExpression nex,
                                                    IEnumerable<ElementInit> initializers)
 {
     if (node.NewExpression != nex || node.Initializers != initializers)
     {
         return Expression.ListInit(nex, initializers);
     }
     return node;
 }

 protected override Expression VisitListInit(ListInitExpression node)
 {
     // If we here, than eval the whole block failed, don't touch constructor!
     _allowEval = false;
     var newExpr = VisitAndConvert(node.NewExpression, "VisitListInit");
     _allowEval = true;
     // ReSharper disable once AssignNullToNotNullAttribute
     return node.Update(newExpr, Visit(node.Initializers, VisitElementInit));
 }

 internal override Expression VisitListInit(ListInitExpression init)
 {
     throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(this.type, init.ToString()));
 }

 internal override Expression VisitListInit(ListInitExpression init)
 {
     throw new NotSupportedException(Strings.ALinq_ListInitNotSupported);
 }

 protected virtual System.Linq.Expressions.Expression VisitListInit(ListInitExpression init)
 {
     NewExpression n = VisitNew(init.NewExpression);
     IEnumerable<ElementInit> initializers = VisitElementInitializerList(init.Initializers);
     // ReSharper disable once PossibleUnintendedReferenceComparison
     if(n != init.NewExpression || initializers != init.Initializers)
     {
         return System.Linq.Expressions.Expression.ListInit(n, initializers);
     }
     return init;
 }

 public virtual void Visit(ListInitExpression expression) {
     if (VisitListInit != null)
         VisitListInit(expression);
 }

 protected override Expression VisitListInit(ListInitExpression init)
 {
     this.Visit(init.NewExpression);
     this.Write(" {");
     this.WriteLine(Indentation.Inner);
     this.VisitElementInitializerList(init.Initializers);
     this.WriteLine(Indentation.Outer);
     this.Write("}");
     return init;
 }

        /// <summary>
        /// Visit a list initializatio expression.
        /// </summary>
        /// <param name="listInitExp"></param>
        /// <returns></returns>
        protected virtual Expression VisitListInit(ListInitExpression listInitExp)
        {
            NewExpression n = VisitNew(listInitExp.NewExpression);
            IEnumerable<ElementInit> initializers = VisitElementInitializerList(listInitExp.Initializers);

            return n != listInitExp.NewExpression || initializers != listInitExp.Initializers
                       ? Expression.ListInit(n, initializers)
                       : listInitExp;
        }

 public ListInitExpressionMutator(ListInitExpression expression)
 {
     ListInitExpression = expression;
 }

 internal virtual Expression VisitListInit(ListInitExpression init)
 {
     var n = VisitNew(init.NewExpression);
     var initializers = VisitElementInitializerList(init.Initializers);
     if (n != init.NewExpression
         || initializers != init.Initializers)
     {
         return Expression.ListInit(n, initializers);
     }
     return init;
 }

 protected virtual Expression VisitListInit(ListInitExpression init, Stack<string> stack, Stack<IElasticPropertyAttribute> properties)
 {
     NewExpression n = this.VisitNew(init.NewExpression, stack, properties);
     IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers, stack, properties);
     if (n != init.NewExpression || initializers != init.Initializers)
     {
         return Expression.ListInit(n, initializers);
     }
     return init;
 }

 /// <summary>
 /// Visits a ListInitExpression.
 /// </summary>
 /// <param name="node">The ListInitExpression.</param>
 /// <returns>The ListInitExpression (possibly modified).</returns>
 protected virtual Expression VisitListInit(ListInitExpression node)
 {
     NewExpression n = VisitNew(node.NewExpression);
     IEnumerable<ElementInit> initializers = VisitElementInitList(node.Initializers);
     return UpdateListInit(node, n, initializers);
 }

 public ListInitExpressionProxy(ListInitExpression node) {
     _node = node;
 }

 private static IList<string> WriteEx(ListInitExpression expression, string header, int depth)
 {
     var lines = new List<string> { WriteHeader(expression, header, depth++) };
     lines.AddRange(Write(expression.NewExpression, "New", depth));
     for (int i = 0; i < expression.Initializers.Count; i++)
     {
         lines.Add(WriteLiteral(expression.Initializers[i].AddMethod.Name, string.Format("Method{0:0##}", i), depth));
         for (int j = 0; j < expression.Initializers[i].Arguments.Count; j++)
         {
             lines.AddRange(Write(expression.Initializers[i].Arguments[j], string.Format("#{0:0##}", j), depth + 1));
         }
     }
     return lines;
 }

 internal override Expression VisitListInit(ListInitExpression init)
 {
     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjectionToEntity, this.type, init.ToString()));
 }

 /// <summary>
 /// Visits a ListInitExpression.
 /// </summary>
 /// <param name="node">The ListInitExpression.</param>
 /// <returns>The ListInitExpression.</returns>
 protected override Expression VisitListInit(ListInitExpression node)
 {
     _sb.Append("<ListInitExpression>");
     return node;
 }

 /// <summary>
 /// ListInitExpression visit method
 /// </summary>
 /// <param name="init">The ListInitExpression to visit</param>
 /// <returns>The visited ListInitExpression</returns>
 internal override Expression VisitListInit(ListInitExpression init)
 {
     this.cantTranslateExpression = true;
     return init;
 }

 /// <summary>
 /// ListInitExpression visit method
 /// </summary>
 /// <param name="init">The ListInitExpression to visit</param>
 /// <returns>The visited ListInitExpression</returns>
 internal override Expression VisitListInit(ListInitExpression init)
 {
     throw new NotImplementedException();
 }

    public virtual bool IsEvaluatableListInit (ListInitExpression node)
    {
      ArgumentUtility.CheckNotNull ("node", node);

      return true;
    }