public static boolean isImplicitCondition(Statement stat) { return stat instanceof ExpressionStatement && !(((ExpressionStatement) stat).getExpression() instanceof DeclarationExpression); }
private static List<Expression> getExpressions(List<Statement> statements) { List<Expression> exprs = new ArrayList<>(); for (Statement stat : statements) if (stat instanceof ExpressionStatement) exprs.add(((ExpressionStatement)stat).getExpression()); return exprs; }
@Override public boolean isMatch(Statement stat) { ExpressionStatement exprStat = ObjectUtil.asInstance(stat, ExpressionStatement.class); if (exprStat == null) return false; Expression expr = exprStat.getExpression(); return expr == binaryExpr || expr == methodCallExpr; }
@Override public void visitExpressionStatement(ExpressionStatement stat) { replaceExpr(stat.getExpression()); }
private static ConstructorCallExpression getFirstIfSpecialConstructorCall(Statement code) { if (!(code instanceof ExpressionStatement)) return null; Expression expression = ((ExpressionStatement) code).getExpression(); if (!(expression instanceof ConstructorCallExpression)) return null; ConstructorCallExpression cce = (ConstructorCallExpression) expression; if (cce.isSpecialCall()) return cce; return null; }
private static boolean extractImplicitThis$0StmtIfInnerClassFromExpression(final List<Statement> stmts, final Statement bstmt) { Expression expr = ((ExpressionStatement) bstmt).getExpression(); if (expr instanceof BinaryExpression) { Expression lExpr = ((BinaryExpression) expr).getLeftExpression(); if (lExpr instanceof FieldExpression) { if ("this$0".equals(((FieldExpression) lExpr).getFieldName())) { stmts.remove(bstmt); // remove from here and let the caller reposition it return true; } } } return false; }
private static ConstructorCallExpression getFirstIfSpecialConstructorCall(BlockStatement code) { if (code == null) return null; final List<Statement> statementList = code.getStatements(); if (statementList.isEmpty()) return null; final Statement statement = statementList.get(0); if (!(statement instanceof ExpressionStatement)) return null; Expression expression = ((ExpressionStatement) statement).getExpression(); if (!(expression instanceof ConstructorCallExpression)) return null; ConstructorCallExpression cce = (ConstructorCallExpression) expression; if (cce.isSpecialCall()) return cce; return null; } }
public static <T extends Expression> T getExpression(Statement stat, Class<T> type) { ExpressionStatement exprStat = ObjectUtil.asInstance(stat, ExpressionStatement.class); if (exprStat == null) return null; return ObjectUtil.asInstance(exprStat.getExpression(), type); }
public static Statement rewriteImplicitCondition(ExpressionStatement stat, IRewriteResources resources) { ConditionRewriter rewriter = new ConditionRewriter(resources); return rewriter.rewriteCondition(stat, stat.getExpression(), null, false); }
public boolean firstStatementIsSpecialConstructorCall() { Statement code = getFirstStatement(); if (!(code instanceof ExpressionStatement)) return false; Expression expression = ((ExpressionStatement) code).getExpression(); if (!(expression instanceof ConstructorCallExpression)) return false; ConstructorCallExpression cce = (ConstructorCallExpression) expression; return cce.isSpecialCall(); }
@Override public void visitExpressionStatement(ExpressionStatement es) { Expression exp = es.getExpression(); exp.visit(this); super.visitExpressionStatement(es); }
@Override public void visitExpressionStatement(ExpressionStatement es) { // GROOVY-3543: visit the declaration expressions so that declaration variables get added on the varStack Expression exp = es.getExpression(); if (exp instanceof DeclarationExpression) { exp.visit(this); } super.visitExpressionStatement(es); }
public void visitExpressionStatement(ExpressionStatement es) { es.setExpression(transform(es.getExpression())); } }
public ReturnStatement(ExpressionStatement statement) { this(statement.getExpression()); setStatementLabel(statement.getStatementLabel()); }
public void writeExpressionStatement(ExpressionStatement statement) { controller.getAcg().onLineNumber(statement, "visitExpressionStatement: " + statement.getExpression().getClass().getName()); writeStatementLabel(statement); Expression expression = statement.getExpression(); int mark = controller.getOperandStack().getStackLength(); expression.visit(controller.getAcg()); controller.getOperandStack().popDownTo(mark); } }
@Override public void visitStatement(Statement node) { if (node.getStatementLabel() != null) { addNode(statements, node.getStatementLabel(), node); if (node instanceof ExpressionStatement) addNode(expressions, node.getStatementLabel(), ((ExpressionStatement)node).getExpression()); } super.visitStatement(node); }
private void extractModelTypesFromStatement(final Statement code, final Map<String, ClassNode> model) { if (code instanceof BlockStatement) { BlockStatement block = (BlockStatement) code; for (Statement statement : block.getStatements()) { extractModelTypesFromStatement(statement, model); } } else if (code instanceof ExpressionStatement) { Expression expression = ((ExpressionStatement) code).getExpression(); if (expression instanceof DeclarationExpression) { VariableExpression var = ((DeclarationExpression) expression).getVariableExpression(); model.put(var.getName(), var.getOriginType()); } } }
private static void visitStatement(Statement statement, ClassNode returnType) { if (statement instanceof ReturnStatement) { // normal path ReturnStatement rs = (ReturnStatement) statement; rs.setExpression(transformConstantExpression(rs.getExpression(), returnType)); } else if (statement instanceof ExpressionStatement) { // path for JavaStubGenerator ExpressionStatement es = (ExpressionStatement) statement; es.setExpression(transformConstantExpression(es.getExpression(), returnType)); } }
public boolean isInteraction(ExpressionStatement stat) throws InvalidSpecCompileException { if (scanResult != null) { if (stat != this.stat) { throw new InvalidSpecCompileException(stat, "InteractionRewriter was reused"); } return scanResult; } this.stat = stat; Expression expr = parseCount(parseResults(stat.getExpression())); boolean interaction = (count != null || !responses.isEmpty()) && parseCall(expr); if (interaction && resources.getCurrentMethod().getAst().isStatic()) { throw new InvalidSpecCompileException(stat, "Interactions cannot be declared in static scope"); } return scanResult = interaction; }
private void createBuilder() { // ExpressionStatements w/ label have wrong source position, // but source position of the contained expression is OK Expression expr = stat.getExpression(); builderExpr = new ConstructorCallExpression( resources.getAstNodeCache().InteractionBuilder, new ArgumentListExpression( Arrays.<Expression> asList( new ConstantExpression(expr.getLineNumber()), new ConstantExpression(expr.getColumnNumber()), new ConstantExpression(resources.getSourceText(expr))))); }