public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
@Override public void visitReturnStatement(ReturnStatement stat) { replaceExpr(stat.getExpression()); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
public void visitReturnStatement(final ReturnStatement statement) { assertStatementAuthorized(statement); statement.getExpression().visit(this); }
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()); } } };
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)); } }
private void visitAnnotationDefault(MethodNode node, MethodVisitor mv) { if (!node.hasAnnotationDefault()) return; Expression exp = ((ReturnStatement) node.getCode()).getExpression(); AnnotationVisitor av = mv.visitAnnotationDefault(); visitAnnotationDefaultExpression(av,node.getReturnType(),exp); }
if (statement instanceof ReturnStatement) { ReturnStatement rs = (ReturnStatement) statement; ex = rs.getExpression(); } else if (statement instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) statement;
private void visitConstructorOrMethod(MethodNode node, int methodTarget) { visitAnnotations(node, methodTarget); for (int i = 0; i < node.getParameters().length; i++) { Parameter parameter = node.getParameters()[i]; visitAnnotations(parameter, AnnotationNode.PARAMETER_TARGET); } if (this.currentClass.isAnnotationDefinition() && !node.isStaticConstructor()) { ErrorCollector errorCollector = new ErrorCollector(this.source.getConfiguration()); AnnotationVisitor visitor = new AnnotationVisitor(this.source, errorCollector); visitor.setReportClass(currentClass); visitor.checkReturnType(node.getReturnType(), node); if (node.getParameters().length > 0) { addError("Annotation members may not have parameters.", node.getParameters()[0]); } if (node.getExceptions().length > 0) { addError("Annotation members may not have a throws clause.", node.getExceptions()[0]); } ReturnStatement code = (ReturnStatement) node.getCode(); if (code != null) { visitor.visitExpression(node.getName(), code.getExpression(), node.getReturnType()); visitor.checkCircularReference(currentClass, node.getReturnType(), code.getExpression()); } this.source.getErrorCollector().addCollectorContents(errorCollector); } Statement code = node.getCode(); if (code != null) { code.visit(this); } }
public void checkCircularReference(ClassNode searchClass, ClassNode attrType, Expression startExp) { if (!isValidAnnotationClass(attrType)) return; if (!(startExp instanceof AnnotationConstantExpression)) { addError("Found '" + startExp.getText() + "' when expecting an Annotation Constant", startExp); return; } AnnotationConstantExpression ace = (AnnotationConstantExpression) startExp; AnnotationNode annotationNode = (AnnotationNode) ace.getValue(); if (annotationNode.getClassNode().equals(searchClass)) { addError("Circular reference discovered in " + searchClass.getName(), startExp); return; } ClassNode cn = annotationNode.getClassNode(); for (MethodNode method : cn.getMethods()) { if (method.getReturnType().equals(searchClass)) { addError("Circular reference discovered in " + cn.getName(), startExp); } ReturnStatement code = (ReturnStatement) method.getCode(); if (code == null) continue; checkCircularReference(searchClass, method.getReturnType(), code.getExpression()); } }
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); }
protected ClassNode checkReturnType(final ReturnStatement statement) { Expression expression = statement.getExpression(); ClassNode type = getType(expression);
@Override public void run() { visit(statement.getExpression()); } });
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
private void visitAnnotationDefault(MethodNode node, MethodVisitor mv) { if (!node.hasAnnotationDefault()) return; Expression exp = ((ReturnStatement) node.getCode()).getExpression(); AnnotationVisitor av = mv.visitAnnotationDefault(); visitAnnotationDefaultExpression(av,node.getReturnType(),exp); }
private void visitAnnotationDefault(MethodNode node, MethodVisitor mv) { if (!node.hasAnnotationDefault()) return; Expression exp = ((ReturnStatement) node.getCode()).getExpression(); AnnotationVisitor av = mv.visitAnnotationDefault(); visitAnnotationDefaultExpression(av,node.getReturnType(),exp); }
private void visitAnnotationDefault(MethodNode node, MethodVisitor mv) { if (!node.hasAnnotationDefault()) return; Expression exp = ((ReturnStatement) node.getCode()).getExpression(); AnnotationVisitor av = mv.visitAnnotationDefault(); visitAnnotationDefaultExpression(av,node.getReturnType(),exp); }