protected override Expression VisitUnary(UnaryExpression node)
{
return Expression.MakeUnary(
node.NodeType,
Visit(node.Operand),
node.Type);
}
protected override Expression VisitUnary(UnaryExpression unaryExpression)
{
if (unaryExpression.NodeType == ExpressionType.Not && unaryExpression.Type.GetUnwrappedNullableType() == typeof(bool))
{
var operand = this.Visit(unaryExpression.Operand);
if (operand is BitBooleanExpression)
{
return Expression.MakeUnary(unaryExpression.NodeType, Expression.Equal(operand, Expression.Constant(true, operand.Type)), typeof(bool));
}
}
else if (unaryExpression.NodeType == ExpressionType.Convert
&& unaryExpression.Type.GetUnwrappedNullableType() == typeof(bool)
&& unaryExpression.Operand.Type.GetUnwrappedNullableType() != typeof(bool))
{
var operand = this.Visit(unaryExpression.Operand);
if (operand is BitBooleanExpression)
{
return Expression.MakeUnary(unaryExpression.NodeType, Expression.Equal(operand, Expression.Constant(true, operand.Type)), typeof(bool));
}
}
return base.VisitUnary(unaryExpression);
}
static Node ParseUnaryNot(UnaryExpression e)
{
string suffix = e.Operand is BinaryExpression ? ")" : null;
string prefix = e.Operand is BinaryExpression ? "!(" : "!";
return new UnaryNode { Prefix = prefix, Operand = Parse(e.Operand), PrefixValue = GetValue(e), Suffix = suffix };
}
protected override Expression VisitUnary(UnaryExpression node) {
if (node.NodeType == ExpressionType.Convert) {
return Expression.ConvertChecked(node.Operand, node.Type);
}
return base.VisitUnary(node);
}
protected override Expression VisitUnary(UnaryExpression node)
{
if (node.NodeType == ExpressionType.Not && node.Operand is MemberExpression)
{
return base.VisitUnary(node);
}
var exp = base.VisitUnary(node);
if (node.NodeType == ExpressionType.Not)
{
string condition = _conditionStack.Pop();
_conditionStack.Push("(NOT " + condition + ")");
}
else if (node.NodeType == ExpressionType.Convert)
{
if (node.Operand is ConstantExpression)
{
_constStack.Push((node.Operand as ConstantExpression).Value);
}
}
else
{
throw new Exception("未支持一元操作符：" + node.NodeType.ToString());
}
return exp;
}
internal static Quote Quote(UnaryExpression expression)
{
return new Quote()
{
Operand = Serialize(expression.Operand),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
}
private static SqlExpression VisitConvert(UnaryExpression expression)
{
if (expression.Operand.NodeType == ExpressionType.MemberAccess) {
return VisitMemberAccess((MemberExpression)expression.Operand);
}
throw new NotImplementedException();
}
protected override Expression VisitUnary(UnaryExpression u)
{
throw new NotSupportedException(
string.Format(
"The unary operator '{0}' is not supported",
u.NodeType));
}
protected override Expression VisitUnary(UnaryExpression node)
{
switch (node.NodeType)
{
case ExpressionType.Not:
if (node.Operand is SubQueryExpression)
{
var nested = new WhereClauseVisitor(_parent, _mapping);
nested.Visit(node.Operand);
var @where = new NotWhereFragment(nested.ToWhereFragment());
_register.Peek()(@where);
}
else
{
var visitor = new NotVisitor(this, _mapping, _register.Peek());
visitor.Visit(node);
}
return null;
}
return base.VisitUnary(node);
}
public void AddQueryPart(UnaryExpression leftItem, ConstantExpression rightValue, ExpressionType nodeType)
{
if(leftItem.Operand is MethodCallExpression)
{
var unaryOperation = (MethodCallExpression)leftItem.Operand;
if(unaryOperation.Method.Name != "get_Item")
{
throw new InvalidOperationException("Queries based on " + leftItem.Method.Name + " are not yet supported.");
}
if(unaryOperation.Arguments[0] is ConstantExpression)
{
var attributeRef = ((ConstantExpression) unaryOperation.Arguments[0]).Value;
AddCriteriaToActiveSearchCondition(attributeRef.ToString(), rightValue.Value, GetSearchRelationType(nodeType));
}
else
{
throw new InvalidOperationException("Only constant expressions are currently supported.");
}
}
else
{
throw new InvalidOperationException("Queries based on " + leftItem.Method.Name + " are not yet supported.");
}
}
protected override Expression VisitUnary(UnaryExpression node)
{
if (node.NodeType != ExpressionType.Convert && node.NodeType != ExpressionType.ConvertChecked)
{
return base.VisitUnary(node);
}
if (node.Operand.NodeType != ExpressionType.MemberAccess)
{
return base.VisitUnary(node);
}
if (!ReflectionHelper.IsNullable(node.Type))
{
return base.VisitUnary(node);
}
MemberExpression memberNode = node.Operand as MemberExpression;
if (memberNode.Expression == null)
{
// Static member access cannot be rewritten
return base.VisitUnary(node);
}
return this.CreateSafeMemberAccessExpression(node.Operand as MemberExpression, node.Type);
}
private Expression ConvertCast(LinqExp.UnaryExpression linqConvert, Func <Expression, Type, MethodInfo, Expression> factory)
{
return(factory.Invoke(
ConvertExp(linqConvert.Operand),
linqConvert.Type,
linqConvert.Method));
}
internal static ArrayLength ArrayLength(UnaryExpression expression)
{
return new ArrayLength()
{
Operand = Serialize(expression.Operand),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
}
public static string GetPropertyName <TModel, TResult>(System.Linq.Expressions.Expression <Func <TModel, TResult> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
string parent = "";
if (typeof(TModel) != memberExpression.Expression.Type) /// sub property // to do hierahly cycle
{
var submemember = memberExpression.Expression as System.Linq.Expressions.MemberExpression;
if (submemember != null)
{
parent = submemember.Member.Name + ".";
}
}
return(parent + ((PropertyInfo)memberExpression.Member).Name);
}
protected override Expression VisitUnary(UnaryExpression node)
{
base.VisitUnary(node);
var filter = stack.Pop();
if (node.NodeType == ExpressionType.Not)
{
stack.Push(new Ast.UnaryExpression
{
Operator = JqlUnaryExpressionType.Not,
Operand = filter
});
}
else if (node.NodeType == ExpressionType.Convert)
{
stack.Push(filter);
}
else
{
throw new InvalidOperationException(
$"not supported unary operator [{node.NodeType}]");
}
return(node);
}
protected override Expression VisitUnary(UnaryExpression u)
{
if (u.NodeType == ExpressionType.Quote)
{
return base.Visit(u.Operand);
}
return base.VisitUnary(u);
}
internal static Unbox Unbox(UnaryExpression expression)
{
return new Unbox()
{
Operand = Serialize(expression.Operand),
Type = TypeRef.Serialize(expression.Type),
};
}
//string GetColumnName(LambdaExpression member)
//{
// var mbody = member.Body as MemberExpression;
// if (mbody != null) return GetColumnName(mbody);
// var ubody = member.Body as UnaryExpression;
// if (ubody == null) throw new NotSupportedException("Only members and unary expressions are supported");
// return GetColumnName(ubody);
//}
private string GetColumnName(UnaryExpression member)
{
var mbody = member.Operand as MemberExpression;
if (mbody != null) return GetColumnName(mbody);
var ubody = member.Operand as UnaryExpression;
if (ubody != null) return GetColumnName(ubody);
throw new NotSupportedException("Only members and unary expressions are supported");
}
internal static PreDecrementAssign PreDecrementAssign(UnaryExpression expression)
{
return new PreDecrementAssign()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
}
protected override Expression VisitUnary(UnaryExpression u)
{
u = (UnaryExpression)base.VisitUnary(u);
if (u.NodeType != ExpressionType.Not)
return u;
return Invert(u.Operand, u);
}
internal static OnesComplement OnesComplement(UnaryExpression expression)
{
return new OnesComplement()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
}
internal static IsFalse IsFalse(UnaryExpression expression)
{
return new IsFalse()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
}
internal static TypeAs TypeAs(UnaryExpression expression)
{
return new TypeAs()
{
Operand = Serialize(expression.Operand),
Type = TypeRef.Serialize(expression.Type),
};
}
internal static NegateChecked NegateChecked(UnaryExpression expression)
{
return new NegateChecked()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
}.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
}
public static XmlAryExpression From(UnaryExpression uex)
{
return new XmlAryExpression
{
NodeType = uex.NodeType,
Method = XmlMetadataInfo.FromMetadata(uex.Method),
Operands = XmlExpression.FromMany(new Expression[]{uex.Operand})
};
}
protected override Expression VisitUnary(UnaryExpression node)
{
if (node.NodeType == ExpressionType.Throw && node.Operand == null)
{
return _replacement;
}
return base.VisitUnary(node);
}
public static UnaryExpressionFingerprint Create(UnaryExpression expression, ParserContext parserContext)
{
ExpressionFingerprint fingerprint = ExpressionFingerprint.Create(expression.Operand, parserContext);
if ((fingerprint == null) && (expression.Operand != null))
{
return null;
}
return new UnaryExpressionFingerprint(expression) { Operand = fingerprint };
}
internal static Rethrow Rethrow(UnaryExpression expression)
{
return new Rethrow()
{
Operand = Serialize(expression.Operand),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
Type = expression.Type.Null(t => TypeRef.Serialize(t)),
}.If(n => n.Type == null, n => n.TypeHint = TypeRef.Serialize(expression.Type));
}
protected override Expression VisitUnaryExpression(UnaryExpression expression)
{
if (expression.NodeType == ExpressionType.Convert)
{
return base.VisitExpression(expression.Operand);
}
return base.VisitUnaryExpression(expression);
}
public static string JsonLocator(Type rootType, UnaryExpression expression)
{
if (expression.NodeType == ExpressionType.Convert)
{
return JsonLocator(rootType, expression.Operand);
}
throw new NotSupportedException();
}
private string GetCode(UnaryExpression e)
{
if (e.NodeType == ExpressionType.Convert)
{
return $"({e.Type}) {e.Operand}";
}
return e.ToString();
}
internal static Convert Convert(UnaryExpression expression)
{
return new Convert()
{
Operand = Serialize(expression.Operand),
Type = TypeRef.Serialize(expression.Type),
Method = expression.Method.Null(m => MethodRef.Serialize(m)),
};
}
protected override Expression VisitUnary(UnaryExpression node)
{
if (node.NodeType == ExpressionType.Convert && node.Type.IsValueType && !node.Operand.Type.IsValueType)
{
return ProtectFromNull(node, node.Operand);
}
return base.VisitUnary(node);
}
public static string GetExpressionText(System.Linq.Expressions.LambdaExpression expression)
{
if (expression.Body != null && expression.Body.NodeType == System.Linq.Expressions.ExpressionType.Convert)
{
System.Linq.Expressions.UnaryExpression exp = expression.Body as System.Linq.Expressions.UnaryExpression;
expression = System.Linq.Expressions.Expression.Lambda(exp.Operand, expression.Parameters.ToArray <System.Linq.Expressions.ParameterExpression>());
}
return(ExpressionHelper.GetExpressionText(expression));
}
/// <summary>
/// 表达式路由
/// </summary>
/// <param name="exp"></param>
/// <returns></returns>
string ExpressionRouter(System.Linq.Expressions.Expression exp)
{
//获取实体列的特性
List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>();
string sb = string.Empty;
if (exp is System.Linq.Expressions.BinaryExpression)//二元运算符
{
System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp);
return(BinarExpressionProvider(be.Left, be.Right, be.NodeType));
}
else if (exp is System.Linq.Expressions.MemberExpression)//成员
{
System.Linq.Expressions.MemberExpression me = ((System.Linq.Expressions.MemberExpression)exp);
return(me.Member.Name);
}
else if (exp is System.Linq.Expressions.NewArrayExpression)//数组
{
System.Linq.Expressions.NewArrayExpression ae = ((System.Linq.Expressions.NewArrayExpression)exp);
StringBuilder tmpstr = new StringBuilder();
foreach (System.Linq.Expressions.Expression ex in ae.Expressions)
{
tmpstr.Append(ExpressionRouter(ex));
tmpstr.Append(",");
}
return(tmpstr.ToString(0, tmpstr.Length - 1));
}
else if (exp is System.Linq.Expressions.MethodCallExpression)//方法
{
return(MethodExpression(exp));
}
else if (exp is System.Linq.Expressions.ConstantExpression)
{
System.Linq.Expressions.ConstantExpression ce = ((System.Linq.Expressions.ConstantExpression)exp);
if (ce.Value == null)
{
return("null");
}
else if (ce.Value is ValueType)
{
return(ce.Value.ToString());
}
else if (ce.Value is string || ce.Value is DateTime || ce.Value is char)
{
//return string.Format("'{0}'", ce.Value.ToString());
return(string.Format("{0}", ce.Value.ToString()));
}
}
else if (exp is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression ue = ((System.Linq.Expressions.UnaryExpression)exp);
return(ExpressionRouter(ue.Operand));
}
return(null);
}
static string PropertyNameFromUnaryExpr(Exprs.UnaryExpression expr)
{
if (expr.NodeType == Exprs.ExpressionType.ArrayLength)
{
return("Length");
}
var mem_expr = expr.Operand as Exprs.MemberExpression;
return(PropertyNameFromMemberExpr(mem_expr));
}
static Reflect.MemberInfo MemberFromExprUnaryExpr(Exprs.UnaryExpression expr)
{
if (expr.NodeType == Exprs.ExpressionType.ArrayLength)
{
throw new NotSupportedException();
}
var mem_expr = expr.Operand as Exprs.MemberExpression;
return(MemberFromExprMemberExpr(mem_expr));
}
public static PropertyInfo GetPropertyName <T>(System.Linq.Expressions.Expression <Func <T, object> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
return((PropertyInfo)memberExpression.Member);
}
public static string GetPropertyName <TModel, TProperty>(System.Linq.Expressions.Expression <Func <TModel, TProperty> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
var xx = (PropertyInfo)memberExpression.Member;
return(((PropertyInfo)memberExpression.Member).Name);
}
public static string GetDisplayName <TModel, TResult>(System.Linq.Expressions.Expression <Func <TModel, TResult> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
var dispnameattr = memberExpression.Member.CustomAttributes.SingleOrDefault(at => at.AttributeType == typeof(DisplayNameAttribute));
if (dispnameattr != null && dispnameattr.ConstructorArguments.Count > 0)
{
return(dispnameattr.ConstructorArguments[0].Value.ToString());
}
return(((PropertyInfo)memberExpression.Member).Name);
}
protected internal override Expression VisitUnary(UnaryExpression node)
{
switch (node.NodeType)
{
case ExpressionType.TypeAs:
Out("(");
break;
case ExpressionType.Not:
Out("Not(");
break;
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
Out("-");
break;
case ExpressionType.UnaryPlus:
Out("+");
break;
case ExpressionType.Quote:
break;
case ExpressionType.Throw:
Out("throw(");
break;
case ExpressionType.Increment:
Out("Increment(");
break;
case ExpressionType.Decrement:
Out("Decrement(");
break;
case ExpressionType.PreIncrementAssign:
Out("++");
break;
case ExpressionType.PreDecrementAssign:
Out("--");
break;
case ExpressionType.OnesComplement:
Out("~(");
break;
default:
Out(node.NodeType.ToString());
Out("(");
break;
}
Visit(node.Operand);
switch (node.NodeType)
{
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.UnaryPlus:
case ExpressionType.PreDecrementAssign:
case ExpressionType.PreIncrementAssign:
case ExpressionType.Quote:
break;
case ExpressionType.TypeAs:
Out(" As ");
Out(node.Type.Name);
Out(")");
break;
case ExpressionType.PostIncrementAssign:
Out("++");
break;
case ExpressionType.PostDecrementAssign:
Out("--");
break;
default:
Out(")");
break;
}
return(node);
}
protected Predicate <object> GenerateFilterPredicate(string propertyName, string filterValue, Type objType, Type propType, FilterOperationItem filterItem)
{
if (filterItem == null)
{
return(null);
}
if (propertyName == null)
{
throw new ArgumentNullException(nameof(propertyName));
}
if (filterValue == null)
{
throw new ArgumentNullException(nameof(filterValue));
}
if (objType == null)
{
throw new ArgumentNullException(nameof(objType));
}
ParameterExpression objParam = linq.Expression.Parameter(typeof(object), "x");
linq.UnaryExpression param = objType.IsByRef ?
linq.Expression.TypeAs(objParam, objType) :
linq.Expression.Convert(objParam, objType);
linq.Expression prop = ExpressionProperty(propertyName, param);
ConstantExpression val = linq.Expression.Constant(filterValue);
switch (filterItem.FilterOption)
{
case Enums.FilterOperation.Contains:
return(ExpressionHelper.GenerateGeneric(prop, val, propType, objParam, "Contains"));
case Enums.FilterOperation.EndsWith:
return(ExpressionHelper.GenerateGeneric(prop, val, propType, objParam, "EndsWith"));
case Enums.FilterOperation.StartsWith:
return(ExpressionHelper.GenerateGeneric(prop, val, propType, objParam, "StartsWith"));
case Enums.FilterOperation.Equals:
return(ExpressionHelper.GenerateEquals(prop, filterValue, propType, objParam));
case Enums.FilterOperation.NotEquals:
return(ExpressionHelper.GenerateNotEquals(prop, filterValue, propType, objParam));
case Enums.FilterOperation.GreaterThanEqual:
return(ExpressionHelper.GenerateGreaterThanEqual(prop, filterValue, propType, objParam));
case Enums.FilterOperation.LessThanEqual:
return(ExpressionHelper.GenerateLessThanEqual(prop, filterValue, propType, objParam));
case Enums.FilterOperation.GreaterThan:
return(ExpressionHelper.GenerateGreaterThan(prop, filterValue, propType, objParam));
case Enums.FilterOperation.LessThan:
return(ExpressionHelper.GenerateLessThan(prop, filterValue, propType, objParam));
default:
throw new ArgumentException("Could not decode Search Mode. Did you add a new value to the enum, or send in Unknown?");
}
}
private Expression Convert(LinqExp.UnaryExpression linqUnary, Func <Expression, Type, Expression> factory)
{
return(factory.Invoke(ConvertExp(linqUnary.Operand), linqUnary.Type));
}
protected internal override Expression VisitUnary(UnaryExpression node)
{
switch (node.NodeType)
{
case ExpressionType.Convert:
Out("(" + node.Type.ToString() + ")");
break;
case ExpressionType.ConvertChecked:
Out("#(" + node.Type.ToString() + ")");
break;
case ExpressionType.TypeAs:
break;
case ExpressionType.Not:
Out(node.Type == typeof(bool) ? "!" : "~");
break;
case ExpressionType.OnesComplement:
Out("~");
break;
case ExpressionType.Negate:
Out("-");
break;
case ExpressionType.NegateChecked:
Out("#-");
break;
case ExpressionType.UnaryPlus:
Out("+");
break;
case ExpressionType.ArrayLength:
break;
case ExpressionType.Quote:
Out("'");
break;
case ExpressionType.Throw:
if (node.Operand == null)
{
Out(".Rethrow");
}
else
{
Out(".Throw", Flow.Space);
}
break;
case ExpressionType.IsFalse:
Out(".IsFalse");
break;
case ExpressionType.IsTrue:
Out(".IsTrue");
break;
case ExpressionType.Decrement:
Out(".Decrement");
break;
case ExpressionType.Increment:
Out(".Increment");
break;
case ExpressionType.PreDecrementAssign:
Out("--");
break;
case ExpressionType.PreIncrementAssign:
Out("++");
break;
case ExpressionType.Unbox:
Out(".Unbox");
break;
}
ParenthesizedVisit(node, node.Operand);
switch (node.NodeType)
{
case ExpressionType.TypeAs:
Out(Flow.Space, ".As", Flow.Space | Flow.Break);
Out(node.Type.ToString());
break;
case ExpressionType.ArrayLength:
Out(".Length");
break;
case ExpressionType.PostDecrementAssign:
Out("--");
break;
case ExpressionType.PostIncrementAssign:
Out("++");
break;
}
return(node);
}
/// <summary>
/// Visits the children of the <see cref="UnaryExpression"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected internal virtual Expression VisitUnary(UnaryExpression node)
{
return(ValidateUnary(node, node.Update(Visit(node.Operand))));
}
protected internal override Expression VisitUnary(UnaryExpression node)
{
switch (node.NodeType)
{
case ExpressionType.Negate:
case ExpressionType.NegateChecked: Out('-'); break;
case ExpressionType.Not: Out("Not("); break;
case ExpressionType.IsFalse: Out("IsFalse("); break;
case ExpressionType.IsTrue: Out("IsTrue("); break;
case ExpressionType.OnesComplement: Out("~("); break;
case ExpressionType.ArrayLength: Out("ArrayLength("); break;
case ExpressionType.Convert: Out("Convert("); break;
case ExpressionType.ConvertChecked: Out("ConvertChecked("); break;
case ExpressionType.Throw: Out("throw("); break;
case ExpressionType.TypeAs: Out('('); break;
case ExpressionType.UnaryPlus: Out('+'); break;
case ExpressionType.Unbox: Out("Unbox("); break;
case ExpressionType.Increment: Out("Increment("); break;
case ExpressionType.Decrement: Out("Decrement("); break;
case ExpressionType.PreIncrementAssign: Out("++"); break;
case ExpressionType.PreDecrementAssign: Out("--"); break;
case ExpressionType.Quote:
case ExpressionType.PostIncrementAssign:
case ExpressionType.PostDecrementAssign:
break;
default:
throw new InvalidOperationException();
}
Visit(node.Operand);
switch (node.NodeType)
{
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.UnaryPlus:
case ExpressionType.PreDecrementAssign:
case ExpressionType.PreIncrementAssign:
case ExpressionType.Quote:
break;
case ExpressionType.TypeAs: Out(" As ");
Out(node.Type.Name);
Out(')'); break;
case ExpressionType.Convert:
case ExpressionType.ConvertChecked: Out(", ");
Out(node.Type.Name);
Out(')'); break; // These were changed in CoreFx to add the type name
case ExpressionType.PostIncrementAssign: Out("++"); break;
case ExpressionType.PostDecrementAssign: Out("--"); break;
default: Out(')'); break;
}
return(node);
}
