public static Statement returnS(Expression expr) { return new ReturnStatement(new ExpressionStatement(expr)); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); return returnStatement; ExpressionStatement expStmt = (ExpressionStatement) statement; Expression expr = expStmt.getExpression(); ReturnStatement ret = new ReturnStatement(expr); ret.setSourcePosition(expr); ret.setStatementLabel(statement.getStatementLabel()); listener.returnStatementAdded(ret); return ret; if (doAdd) list.set(idx, last); if (!statementReturns(last)) { final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); if (doAdd) list.add(returnStatement); ReturnStatement ret = new ReturnStatement(ConstantExpression.NULL); ret.setSourcePosition(block); listener.returnStatementAdded(ret); return ret; final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); return returnStatement; final List list = new ArrayList(); list.add(statement);
public void visitReturnStatement(ReturnStatement statement) { statement.setExpression(transform(statement.getExpression())); }
public void returnStatementAdded(final ReturnStatement returnStatement) { if (returnStatement.getExpression() == ConstantExpression.NULL) return; if (isNullConstant(returnStatement.getExpression())) return; checkReturnType(returnStatement); if (typeCheckingContext.getEnclosingClosure() != null) { addClosureReturnType(getType(returnStatement.getExpression())); } else if (typeCheckingContext.getEnclosingMethod() != null) { } else { throw new GroovyBugError("Unexpected return statement at " + returnStatement.getLineNumber() + ":" + returnStatement.getColumnNumber() + " " + returnStatement.getText()); } } };
/** * Gets a list of {@link org.codehaus.groovy.ast.stmt.ReturnStatement} instances from the given {@link MethodNode}. * * @param method the {@link org.codehaus.groovy.ast.MethodNode} that holds the given <tt>lastStatement</tt> * @return a {@link org.codehaus.groovy.ast.stmt.ReturnStatement} or <tt>null</tt> */ public static List<ReturnStatement> getReturnStatements(MethodNode method) { final ReturnStatementVisitor returnStatementVisitor = new ReturnStatementVisitor(); returnStatementVisitor.visitMethod(method); final List<ReturnStatement> returnStatements = returnStatementVisitor.getReturnStatements(); final BlockStatement blockStatement = (BlockStatement) method.getCode(); if (returnStatements.isEmpty()) { final int statementCount = blockStatement.getStatements().size(); if (statementCount > 0) { final Statement lastStatement = blockStatement.getStatements().get(statementCount - 1); if (lastStatement instanceof ExpressionStatement) { final ReturnStatement returnStatement = new ReturnStatement((ExpressionStatement) lastStatement); returnStatement.setSourcePosition(lastStatement); blockStatement.getStatements().remove(lastStatement); blockStatement.addStatement(returnStatement); returnStatements.add(returnStatement); } } } return returnStatements; }
@Override public void visitBlockStatement(BlockStatement block) { blockStatement = block; blockStatementCopy = new BlockStatement(new ArrayList<Statement>(blockStatement.getStatements()), blockStatement.getVariableScope()); blockStatementCopy.copyNodeMetaData(blockStatement); blockStatementCopy.setSourcePosition(blockStatement); for (Statement statement : blockStatementCopy.getStatements()) { if (statement == returnStatement) { blockStatement.getStatements().remove(statement); final VariableExpression $_gc_result = new VariableExpression("$_gc_result", ClassHelper.DYNAMIC_TYPE); $_gc_result.setAccessedVariable($_gc_result); blockStatement.addStatement(new ExpressionStatement( new DeclarationExpression($_gc_result, Token.newSymbol(Types.ASSIGN, -1, -1), returnStatement.getExpression()) )); blockStatement.addStatement(assertionCallStatement); ReturnStatement gcResultReturn = new ReturnStatement($_gc_result); gcResultReturn.setSourcePosition(returnStatement); blockStatement.addStatement(gcResultReturn); return; // we found the return statement under target, let's cancel tree traversal } } super.visitBlockStatement(blockStatement); } }
public void writeReturn(ReturnStatement statement) { controller.getAcg().onLineNumber(statement, "visitReturnStatement"); writeStatementLabel(statement); MethodVisitor mv = controller.getMethodVisitor(); OperandStack operandStack = controller.getOperandStack(); ClassNode returnType = controller.getReturnType(); if (returnType == ClassHelper.VOID_TYPE) { if (!(statement.isReturningNullOrVoid())) { //TODO: move to Verifier controller.getAcg().throwException("Cannot use return statement with an expression on a method that returns void"); } controller.getCompileStack().applyBlockRecorder(); mv.visitInsn(RETURN); return; } Expression expression = statement.getExpression(); expression.visit(controller.getAcg()); operandStack.doGroovyCast(returnType); if (controller.getCompileStack().hasBlockRecorder()) { ClassNode type = operandStack.getTopOperand(); int returnValueIdx = controller.getCompileStack().defineTemporaryVariable("returnValue", returnType, true); controller.getCompileStack().applyBlockRecorder(); operandStack.load(type, returnValueIdx); controller.getCompileStack().removeVar(returnValueIdx); } BytecodeHelper.doReturn(mv, returnType); operandStack.remove(1); }
public ReturnStatement(ExpressionStatement statement) { this(statement.getExpression()); setStatementLabel(statement.getStatementLabel()); }
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)); } }
return new ReturnStatement(ConstantExpression.NULL); ExpressionStatement expStmt = (ExpressionStatement) statement; Expression expr = expStmt.getExpression(); ReturnStatement ret = new ReturnStatement(expr); ret.setSourcePosition(expr); return ret; list.set(idx, last); if (!statementReturns(last)) { list.add(new ReturnStatement(ConstantExpression.NULL)); ReturnStatement ret = new ReturnStatement(ConstantExpression.NULL); ret.setSourcePosition(block); return ret; return new ReturnStatement(ConstantExpression.NULL); else { final List list = new ArrayList(); list.add(statement); list.add(new ReturnStatement(ConstantExpression.NULL)); return new BlockStatement(list,new VariableScope(scope));
if (!(statement.isReturningNullOrVoid())) { throwException("Cannot use return statement with an expression on a method that returns void"); Expression expression = statement.getExpression(); evaluateExpression(expression); if (returnType == ClassHelper.OBJECT_TYPE && expression.getType() != null && expression.getType() == ClassHelper.VOID_TYPE) {
public ReturnStatement(ExpressionStatement statement) { this(statement.getExpression()); setStatementLabel(statement.getStatementLabel()); }
private static void setMethodDefaultValue(MethodNode mn, Method m) { Object defaultValue = m.getDefaultValue(); ConstantExpression cExp = ConstantExpression.NULL; if (defaultValue!=null) cExp = new ConstantExpression(defaultValue); mn.setCode(new ReturnStatement(cExp)); mn.setAnnotationDefault(true); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
if (statement instanceof ReturnStatement) { ReturnStatement rs = (ReturnStatement) statement; ex = rs.getExpression(); } else if (statement instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) statement; rs.setExpression(assignment); } else if (statement instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) statement;
return new ReturnStatement(ConstantExpression.NULL); ExpressionStatement expStmt = (ExpressionStatement) statement; Expression expr = expStmt.getExpression(); ReturnStatement ret = new ReturnStatement(expr); ret.setSourcePosition(expr); ret.setStatementLabel(statement.getStatementLabel()); return ret; list.set(idx, last); if (!statementReturns(last)) { list.add(new ReturnStatement(ConstantExpression.NULL)); ReturnStatement ret = new ReturnStatement(ConstantExpression.NULL); ret.setSourcePosition(block); return ret; return new ReturnStatement(ConstantExpression.NULL); else { final List list = new ArrayList(); list.add(statement); list.add(new ReturnStatement(ConstantExpression.NULL)); return new BlockStatement(list,new VariableScope(scope));
ExpressionStatement expStmt = (ExpressionStatement) statement; Expression expr = expStmt.getExpression(); ReturnStatement ret = new ReturnStatement(expr); ret.setSourcePosition(expr); node.setCode(ret); if (last instanceof ExpressionStatement) { ExpressionStatement expStmt = (ExpressionStatement) last; ReturnStatement ret = new ReturnStatement(expStmt); ret.setSourcePosition(expStmt); list.set(idx, ret); } else if (!(last instanceof ReturnStatement)) { list.add(new ReturnStatement(ConstantExpression.NULL)); list.add(new ReturnStatement(ConstantExpression.NULL));
if (!(statement.isReturningNullOrVoid())) { throwException("Cannot use return statement with an expression on a method that returns void"); Expression expression = statement.getExpression(); evaluateExpression(expression); if (returnType == ClassHelper.OBJECT_TYPE && expression.getType() != null && expression.getType() == ClassHelper.VOID_TYPE) {
public ReturnStatement(ExpressionStatement statement) { this(statement.getExpression()); setStatementLabel(statement.getStatementLabel()); }