/// <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"); }