public Expression visit(TypeBinaryExpression typeBinaryExpression, Expression expression) { return typeBinaryExpression.expression == expression ? typeBinaryExpression : new TypeBinaryExpression(expression.getNodeType(), expression, expression.type); }
/** * Returns the expression representing the ones complement. */ public static UnaryExpression onesComplement(Expression expression, Method method) { return makeUnary(ExpressionType.OnesComplement, expression, expression.getType(), method); }
static <T extends Expression> Expression accept(T node, Shuttle shuttle) { if (node == null) { return null; } return node.accept(shuttle); }
/** * Treats two expressions equal even if they represent different null types */ private static boolean eq(Expression a, Expression b) { return a.equals(b) || (a instanceof ConstantExpression && b instanceof ConstantExpression && ((ConstantExpression) a).value == ((ConstantExpression) b).value); } }
typeFactory.createJavaType( Types.toClass( Types.getElementType(call.targetExpression.getType()))), ImmutableList.of(), call.targetExpression)); "unknown expression type " + expression.getNodeType());
: expression2; if (expression1.equals(expression2)) { && (expression0.getNodeType() == ExpressionType.Equal || expression0.getNodeType() == ExpressionType.NotEqual)) { BinaryExpression cmp = (BinaryExpression) expression0; Expression expr = null; expr = expression0.getNodeType() == ExpressionType.Equal ? expression2 : expression1; expr = expression0.getNodeType() == ExpressionType.Equal ? expression2 : expression1;
&& expression0.getNodeType() == ExpressionType.Conditional) { TernaryExpression ternary = (TernaryExpression) expression0; Expression expr = null; expr = Expressions.not(expr); return expr.accept(this);
@Override public Object evaluate(Evaluator evaluator) { switch (kind) { case Return: case Sequence: // NOTE: We ignore control flow. This is only correct if "return" // is the last statement in the block. return expression.evaluate(evaluator); default: throw new AssertionError("evaluate not implemented"); } }
/** * Generates field name to store given expression. * The expression is converted to string and all the non-ascii/numeric * characters are replaced with underscores and {@code "_$L4J$C$"} suffix is * added to avoid conflicts with other variables. * When multiple variables are mangled to the same name, * counter is used to avoid conflicts. * * @param expression input expression * @return unique name to store given expression */ protected String inventFieldName(Expression expression) { String exprText = expression.toString(); exprText = PREFIX_PATTERN.matcher(exprText).replaceAll(""); exprText = FIELD_PREFIX + NON_ASCII.matcher(exprText).replaceAll("_"); if (exprText.length() > 70) { exprText = exprText.substring(0, 70) + Integer.toHexString(exprText.hashCode()); } String fieldName = exprText; for (int i = 0; hasField(fieldName); i++) { fieldName = exprText + i; } return fieldName; }
/** * Returns whether an expression always evaluates to true or false. * Assumes that expression has already been optimized. */ private static Boolean always(Expression x) { if (x.equals(FALSE_EXPR) || x.equals(BOXED_FALSE_EXPR)) { return Boolean.FALSE; } if (x.equals(TRUE_EXPR) || x.equals(BOXED_TRUE_EXPR)) { return Boolean.TRUE; } return null; }
typeFactory.createJavaType( Types.toClass( Types.getElementType(call.targetExpression.getType()))), ImmutableList.of(), call.targetExpression)); "unknown expression type " + expression.getNodeType());
@Override public Object evaluate(Evaluator evaluator) { final Object target; if (targetExpression == null) { target = null; } else { target = targetExpression.evaluate(evaluator); } final Object[] args = new Object[expressions.size()]; for (int i = 0; i < expressions.size(); i++) { Expression expression = expressions.get(i); args[i] = expression.evaluate(evaluator); } try { return method.invoke(target, args); } catch (IllegalAccessException | InvocationTargetException e) { throw new RuntimeException("error while evaluating " + this, e); } }
BinaryExpression(ExpressionType nodeType, Type type, Expression expression0, Expression expression1) { super(nodeType, type); assert expression0 != null : "expression0 should not be null"; assert expression1 != null : "expression1 should not be null"; this.expression0 = expression0; this.expression1 = expression1; this.primitive = Primitive.of(expression0.getType()); }
public R visit(MemberExpression memberExpression) { R r = null; if (memberExpression.expression != null) { r = memberExpression.expression.accept(this); } return r; }
@Override public Expression visit(UnaryExpression unaryExpression, Expression expression) { Expression result = super.visit(unaryExpression, expression); if (isConstant(expression)) { constants.put(result, true); if (result.getNodeType() != ExpressionType.Convert) { return createField(result); } } return result; }
public Object evaluate(Evaluator evaluator) { final Object o = expression == null ? null : expression.evaluate(evaluator); try { return field.get(o); } catch (IllegalAccessException e) { throw new RuntimeException("error while evaluating " + this, e); } }
/** * Creates a UnaryExpression that decrements the expression by 1 * and assigns the result back to the expression. */ public static UnaryExpression preDecrementAssign(Expression expression, Method method) { return makeUnary(ExpressionType.PreDecrementAssign, expression, expression.getType(), method); }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } if (!super.equals(o)) { return false; } BinaryExpression that = (BinaryExpression) o; if (!expression0.equals(that.expression0)) { return false; } if (!expression1.equals(that.expression1)) { return false; } if (primitive != that.primitive) { return false; } return true; }