/// <summary>
/// Resolves types for the specified expression.
/// </summary>
/// <param name="expression">The expression to resolve types for.</param>
/// <returns>Expression with resolved types.</returns>
public QueryExpression Visit(LinqNewArrayExpression expression)
{
var resolvedChildExpressions = this.ResolveTypesForArguments(expression.Expressions).ToList();
var expressionType = expression.ExpressionType;
if (expressionType.IsUnresolved)
{
ExceptionUtilities.Assert(resolvedChildExpressions.Count > 0, "Cannot resolve type of empty array expression");
var elementType = resolvedChildExpressions[0].ExpressionType;
for (int i = 1; i < resolvedChildExpressions.Count; i++)
{
var nextType = resolvedChildExpressions[i].ExpressionType;
// if the next type is less-derived than the current one, we need to move it
// however, because equivalent types are also assignable, we can always take it if this
// check is true
if (nextType.IsAssignableFrom(elementType))
{
elementType = nextType;
}
}
expressionType = elementType.CreateCollectionType();
}
return(new LinqNewArrayExpression(expressionType, resolvedChildExpressions));
}
/// <summary>
/// Evaluates the specified expression.
/// </summary>
/// <param name="expression">The expression to evaluate.</param>
/// <returns>Value of the expression.</returns>
public QueryValue Visit(LinqNewArrayExpression expression)
{
List <QueryValue> queryValues = new List <QueryValue>();
foreach (var childExpression in expression.Expressions)
{
queryValues.Add(this.Evaluate(childExpression));
}
return(expression.ExpressionType.CreateCollectionType().CreateCollectionWithValues(queryValues));
}
/// <summary>
/// Replaces the given expression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>Replaced expression.</returns>
public virtual QueryExpression Visit(LinqNewArrayExpression expression)
{
List <QueryExpression> childExpressions = new List <QueryExpression>();
foreach (var childExpression in expression.Expressions)
{
childExpressions.Add(childExpression.Accept(this));
}
if (HasChanged(expression.Expressions.ToList(), childExpressions))
{
return(new LinqNewArrayExpression(expression.ExpressionType, childExpressions));
}
return(expression);
}
/// <summary>
/// Generates System.CodeDom.CodeExpression from the given expression.
/// </summary>
/// <param name="expression">Expression from which System.CodeDom.CodeExpression is generated.</param>
/// <returns>Generated System.CodeDom.CodeExpression.</returns>
public virtual CodeExpression Visit(LinqNewArrayExpression expression)
{
List <CodeExpression> codeExpressions = new List <CodeExpression>();
foreach (var childQueryExpression in expression.Expressions)
{
codeExpressions.Add(this.GenerateCode(childQueryExpression));
}
var collectionType = expression.ExpressionType as QueryCollectionType;
ExceptionUtilities.CheckObjectNotNull(collectionType, "Expecting expression type to be a collection.");
var clrQueryType = collectionType.ElementType as IQueryClrType;
if (clrQueryType != null)
{
return(new CodeArrayCreateExpression(Code.TypeRef(clrQueryType.ClrType), codeExpressions.ToArray()));
}
else
{
return(Code.Array(codeExpressions.ToArray()));
}
}
/// <summary>
/// Visits a QueryExpression tree whose root node is the LinqNewArrayExpression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>Uri query string representing the expression.</returns>
public virtual string Visit(LinqNewArrayExpression expression)
{
throw new TaupoNotSupportedException("Not supported");
}
