/** * Creates a UnaryExpression that represents a type conversion * operation. */ public static UnaryExpression convert_(Expression expression, Type type) { return new UnaryExpression(ExpressionType.Convert, type, expression); }
@Override public Expression visit(UnaryExpression unaryExpression, Expression expression) { if (unaryExpression.getNodeType().modifiesLvalue) { expression = unaryExpression.expression; // avoid substitution if (expression instanceof ParameterExpression) { // avoid "optimization of" int t=1; t++; to 1++ return unaryExpression; } } return super.visit(unaryExpression, expression); }
@Override public Expression visit(UnaryExpression unaryExpression, Expression expression) { switch (unaryExpression.getNodeType()) { case Convert: if (expression.getType() == unaryExpression.getType()) { return expression; unaryExpression.getType()); if (arg.getNodeType() == ExpressionType.Not) { return arg.expression;
UnaryExpression una = (UnaryExpression) operand; if (una.nodeType == ExpressionType.Convert || Primitive.of(una.getType()) == toBox) { return Expressions.box(una.expression, toBox);
UnaryExpression una = (UnaryExpression) operand; if (una.nodeType == ExpressionType.Convert || Primitive.of(una.getType()) == toBox) { return Expressions.box(una.expression, toBox);
/** * Creates a UnaryExpression, given an operand and implementing * method, by calling the appropriate factory method. */ public static UnaryExpression makeUnary(ExpressionType expressionType, Expression expression, Type type, Method method) { assert type != null; return new UnaryExpression(expressionType, type, expression); }
/** * Checks if expression is simple enough to always inline at zero cost. * * @param expr expression to test * @return true when given expression is safe to always inline */ protected boolean isSimpleExpression(Expression expr) { if (expr instanceof ParameterExpression || expr instanceof ConstantExpression) { return true; } if (expr instanceof UnaryExpression) { UnaryExpression una = (UnaryExpression) expr; return una.getNodeType() == ExpressionType.Convert && isSimpleExpression(una.expression); } return false; }
/** * Creates a UnaryExpression that represents an explicit * unboxing. */ public static UnaryExpression unbox(Expression expression, Type type) { return new UnaryExpression(ExpressionType.Unbox, type, expression); }
if (una.getNodeType() == ExpressionType.Not) { return Expressions.makeTernary(ternary.getNodeType(), una.expression, expression2, expression1);
/** * Creates a UnaryExpression, given an operand, by calling the * appropriate factory method. */ public static UnaryExpression makeUnary(ExpressionType expressionType, Expression expression) { Type type = expression.getType(); switch (expressionType) { case Negate: if (type == byte.class || type == short.class) { type = int.class; } } return new UnaryExpression(expressionType, type, expression); }