internal static NewArrayInit NewArrayInit(NewArrayExpression expression)
 {
     return new NewArrayInit()
     {
         Type = TypeRef.Serialize(expression.Type.GetElementType()),
         Expressions = expression.Expressions.Any()
             ? expression.Expressions.Select(Serialize).ToArray()
             : null,
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }

        private IArgumentConstraint CreateParamArrayConstraint(NewArrayExpression expression)
        {
            var result = new List<IArgumentConstraint>();

            foreach (var argumentExpression in expression.Expressions)
            {
                result.Add(this.GetArgumentConstraintFromExpression(argumentExpression));
            }

            return new AggregateArgumentConstraint(result);
        }

        protected override Expression VisitNewArray(NewArrayExpression node)
        {
            List<Visitor> elementVisitors = node.Expressions.Select(_ => new Visitor()).ToList();
            List<Expression> elementExpressions = elementVisitors.Zip(node.Expressions, (v, e) => v.Visit(e)).ToList();

            NewArrayExpression arrayExpression = Expression.NewArrayInit(elementExpressions.First().Type, elementExpressions);

            foreach (Visitor visitor in elementVisitors)
                _captureNode.AddChild(visitor.CaptureNode);

            return arrayExpression;
        }

 protected virtual Expression ProcessNewArrayExpression(NewArrayExpression expression)
 {
     var notFirst = false;
     foreach (var member in expression.Expressions)
     {
         if (notFirst)
             CommandTextBuilder.Append(",");
         
         ProcessExpression(member);
         notFirst = true;
     }
     return expression;
 }

 static Node ParseExpression(NewArrayExpression e)
 {
     switch (e.NodeType)
     {
         case ExpressionType.NewArrayInit:
             Type t = e.Type.GetElementType();
             return new NewArrayNode
             {
                 Items = e.Expressions.Select(Parse).ToList(),
                 Type = NameOfType(t)
             };
         case ExpressionType.NewArrayBounds:
         //todo:
         default:
             throw new ArgumentOutOfRangeException();
     }
 }

        protected override Expression VisitNewArray(NewArrayExpression node)
        {
            if (node.Type != typeof(Byte[]))
            {
                String message = String.Format("Resources.ExpressionEvaluatorTypeNotSupported {0}", node.Type);
                throw new NotSupportedException(message);
            }

            var array = new Byte[node.Expressions.Count];

            for (int i = 0; i < node.Expressions.Count; i++)
            {
                ConstantExpression result = TryToEvaluate(node.Expressions[i]);
                array[i] = (Byte)result.Value;
            }

            return Expression.Constant(array, node.Type);
        }

		protected override Expression VisitNewArray(NewArrayExpression expression)
		{
			if (expression.Type.GetArrayRank() == 1 && !expression.Type.GetElementType().IsDataAccessObjectType())
			{
				if (expression.Expressions.All(c => c.Type.IsDataAccessObjectType()))
				{
					if (expression.NodeType == ExpressionType.NewArrayInit)
					{
						return Expression.NewArrayInit(typeof(DataAccessObject), this.VisitExpressionList(expression.Expressions));
					}
					else
					{
						return Expression.NewArrayBounds(typeof(DataAccessObject), this.VisitExpressionList(expression.Expressions));
					}
				}
			}

			return base.VisitNewArray(expression);
		}

 protected override Expression VisitNewArray(NewArrayExpression na)
 {
     this.Write("new ");
     this.Write(this.GetTypeName(TypeHelper.GetElementType(na.Type)));
     this.Write("[] {");
     if (na.Expressions.Count > 1)
         this.WriteLine(Indentation.Inner);
     this.VisitExpressionList(na.Expressions);
     if (na.Expressions.Count > 1)
         this.WriteLine(Indentation.Outer);
     this.Write("}");
     return na;
 }

        static IEnumerable<Expression> CreateArrayInitExpressions(NewArrayExpression newArray, Expression valueExpression, Expression indexExpression)
        {
            if (newArray.NodeType == ExpressionType.NewArrayInit)
            {
                var indexGetter = (Func<int>) Expression.Lambda(indexExpression).Compile();
                var index = indexGetter();
                var expressions = newArray.Expressions.ToArray();

                if (index >= newArray.Expressions.Count)
                {
                    Array.Resize(ref expressions, index + 1);
                }

                expressions[index] = valueExpression;

                return expressions;
            }

            return new[] {valueExpression};
        }

 protected NewArrayExpression UpdateNewArray(NewArrayExpression na, Type arrayType, IEnumerable<Expression> expressions)
 {
     if (expressions != na.Expressions || na.Type != arrayType)
     {
         if (na.NodeType == ExpressionType.NewArrayInit)
         {
             return Expression.NewArrayInit(arrayType.GetElementType(), expressions);
         }
         else
         {
             return Expression.NewArrayBounds(arrayType.GetElementType(), expressions);
         }
     }
     return na;
 }

 protected virtual Expression VisitNewArray(NewArrayExpression na)
 {
     IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions);
     return this.UpdateNewArray(na, na.Type, exprs);
 }

 internal override Expression VisitNewArray(NewArrayExpression na)
 {
     throw new NotSupportedException(Strings.ALinq_NewArrayNotSupported);
 }

 protected virtual System.Linq.Expressions.Expression VisitNewArray(NewArrayExpression na)
 {
     IEnumerable<System.Linq.Expressions.Expression> exprs = VisitExpressionList(na.Expressions);
     // ReSharper disable once PossibleUnintendedReferenceComparison
     if(exprs != na.Expressions)
     {
         if(na.NodeType == ExpressionType.NewArrayInit)
         {
             return System.Linq.Expressions.Expression.NewArrayInit(na.Type.GetElementType(), exprs);
         }
         return System.Linq.Expressions.Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
     }
     return na;
 }

        /// <summary>
        /// Visit a new array expression.
        /// </summary>
        /// <param name="newArrayExp"></param>
        /// <returns></returns>
        protected virtual Expression VisitNewArray(NewArrayExpression newArrayExp)
        {
            IEnumerable<Expression> exprs = VisitList(newArrayExp.Expressions);
            if (exprs != newArrayExp.Expressions)
            {
                return newArrayExp.NodeType == ExpressionType.NewArrayInit
                    ? Expression.NewArrayInit(newArrayExp.Type.GetElementType(), exprs)
                    : Expression.NewArrayBounds(newArrayExp.Type.GetElementType(), exprs);
            }

            return newArrayExp;
        }

 internal override Expression VisitNewArray(NewArrayExpression na)
 {
     throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(this.type, na.ToString()));
 }

 protected virtual IList<object> CompileNewArrayFromExpressionList(NewArrayExpression na)
 {
     return CompileExpressionList(na.Expressions);
 }

        protected virtual object CompileNewArray(NewArrayExpression na)
        {
            var exprs = CompileExpressionList(na.Expressions);
            var sb = new StringBuilder();
            foreach (var e in exprs)
            {
                sb.Append(sb.Length > 0 ? "," + e : e);
            }

            return sb.ToString();
        }

        private Expression CreateInRangeExpression(Expression leftExpression, NewArrayExpression asRightRange)
        {
            var lower = (asRightRange.Expressions[0] as ConstantExpression).Value;
            var upper = (asRightRange.Expressions[1] as ConstantExpression).Value;

            lower = ChangeType(lower, leftExpression.Type);
            upper = ChangeType(upper, leftExpression.Type);

            if (Modifier == ModifierTypes.LessThan)
            {
                return Expression.LessThan(leftExpression, Expression.Constant(lower));
            }
            if (Modifier == ModifierTypes.GreaterThan)
            {
                return Expression.GreaterThan(leftExpression, Expression.Constant(upper));
            }
            else
            {
                if (lower.Equals(upper))
                {
                    return Expression.Equal(leftExpression, Expression.Constant(lower));
                }
                else
                {
                    return Expression.AndAlso
                    (
                        Expression.LessThanOrEqual(leftExpression, Expression.Constant(upper)),
                        Expression.GreaterThanOrEqual(leftExpression, Expression.Constant(lower))
                    );
                }
            }
        }

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

		protected HqlTreeNode VisitNewArrayExpression(NewArrayExpression expression)
		{
			var visitor = new HqlGeneratorExpressionTreeVisitor(_parameters);
			var expressionSubTree = expression.Expressions.Select(exp => visitor.Visit(exp));
			return _hqlTreeBuilder.ExpressionSubTreeHolder(expressionSubTree);
		}