@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getReturnedExpression()))); }
/** * Returns the expression. */ @SuppressWarnings("unchecked") public static <T> CtExpression<T> getExpression( CtClass<? extends ExpressionTemplate<?>> p) { CtBlock<?> b = getExpressionBlock(p); return ((CtReturn<T>) b.getStatements().get(0)).getReturnedExpression(); }
@Override public <R> void visitCtReturn(CtReturn<R> returnStatement) { enterCtStatement(returnStatement); printer.writeKeyword("return"); // checkstyle wants "return;" and not "return ;" if (returnStatement.getReturnedExpression() != null) { printer.writeSpace(); } scan(returnStatement.getReturnedExpression()); exitCtStatement(returnStatement); }
public <R> void visitCtReturn(final spoon.reflect.code.CtReturn<R> returnStatement) { spoon.reflect.code.CtReturn other = ((spoon.reflect.code.CtReturn) (this.stack.peek())); enter(returnStatement); biScan(spoon.reflect.path.CtRole.ANNOTATION, returnStatement.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.EXPRESSION, returnStatement.getReturnedExpression(), other.getReturnedExpression()); biScan(spoon.reflect.path.CtRole.COMMENT, returnStatement.getComments(), other.getComments()); exit(returnStatement); }
/** * Sets a template model from return expression of the method of template type selected by filter * @param filter the {@link Filter} whose match defines to be used {@link CtExecutable} */ private void setReturnExpressionOfMethod(Filter<CtMethod<?>> filter) { CtMethod<?> method = getOneByFilter(filter); CtBlock<?> body = method.getBody(); if (body.getStatements().size() != 1) { throw new SpoonException("The body of " + method.getSignature() + " must contain exactly one statement. But there is:\n" + body.toString()); } CtStatement firstStatement = body.getStatements().get(0); if (firstStatement instanceof CtReturn<?> == false) { throw new SpoonException("The body of " + method.getSignature() + " must contain return statement. But there is:\n" + body.toString()); } setElements(Collections.singletonList(((CtReturn<?>) firstStatement).getReturnedExpression())); }
@SuppressWarnings("unchecked") public static <T> CtExpression<T> compileExpression( CtCodeSnippetExpression<T> expr) throws SnippetCompilationError { CtReturn<T> ret = (CtReturn<T>) internalCompileStatement(expr, expr.getFactory().Type().OBJECT); CtExpression<T> returnedExpression = ret.getReturnedExpression(); // this compiled expression is not in a parent, ready to be used returnedExpression.delete(); returnedExpression.setParent(null); return returnedExpression; }
@Override public <R> void visitCtReturn(CtReturn<R> returnStatement) { CtReturn<R> r = returnStatement.getFactory().Core().createReturn(); r.setReturnedExpression(evaluate(returnStatement.getReturnedExpression())); setResult(r); flowEnded = true; }
public <R> void visitCtReturn(final CtReturn<R> returnStatement) { enter(returnStatement); scan(CtRole.ANNOTATION, returnStatement.getAnnotations()); scan(CtRole.EXPRESSION, returnStatement.getReturnedExpression()); scan(CtRole.COMMENT, returnStatement.getComments()); exit(returnStatement); }
@java.lang.Override public <R> void visitCtReturn(final spoon.reflect.code.CtReturn<R> returnStatement) { replaceInListIfExist(returnStatement.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(returnStatement)); replaceElementIfExist(returnStatement.getReturnedExpression(), new spoon.support.visitor.replace.ReplacementVisitor.CtReturnReturnedExpressionReplaceListener(returnStatement)); replaceInListIfExist(returnStatement.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(returnStatement)); }
public <R> void visitCtReturn(final spoon.reflect.code.CtReturn<R> returnStatement) { spoon.reflect.code.CtReturn<R> aCtReturn = returnStatement.getFactory().Core().createReturn(); this.builder.copy(returnStatement, aCtReturn); aCtReturn.setAnnotations(this.cloneHelper.clone(returnStatement.getAnnotations())); aCtReturn.setReturnedExpression(this.cloneHelper.clone(returnStatement.getReturnedExpression())); aCtReturn.setComments(this.cloneHelper.clone(returnStatement.getComments())); this.cloneHelper.tailor(returnStatement, aCtReturn); this.other = aCtReturn; }
CtStatement last = b.getStatements().get(b.getStatements().size() - 1); if ((last instanceof CtReturn)) { if (((CtReturn<?>) last).getReturnedExpression() instanceof CtLiteral) { setResult(((CtReturn<?>) last).getReturnedExpression()); return;
/** * Returns the expression. */ @SuppressWarnings("unchecked") public static <T> CtExpression<T> getExpression( CtClass<? extends ExpressionTemplate<?>> p) { CtBlock<?> b = getExpressionBlock(p); return ((CtReturn<T>) b.getStatements().get(0)).getReturnedExpression(); }
public <R> void visitCtReturn(CtReturn<R> returnStatement) { write("return "); scan(returnStatement.getReturnedExpression()); }
public <R> void visitCtReturn(CtReturn<R> returnStatement) { enterCtStatement(returnStatement); write("return "); scan(returnStatement.getReturnedExpression()); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public <R> void visitCtReturn(CtReturn<R> returnStatement) { super.visitCtReturn(returnStatement); CtExpression exper=returnStatement.getReturnedExpression(); if (candidates.containsKey(exper)) { returnStatement.setReturnedExpression(candidates.get(exper)); saveSketchAndSynthesize(); returnStatement.setReturnedExpression(exper); resoreDiskFile(); } }
@SuppressWarnings("unchecked") public CtExpression<T> apply(CtType<?> targetType) { CtClass<? extends ExpressionTemplate<?>> c; CtBlock<?> b; c = targetType.getFactory().Class().get(this.getClass()); if (c == null) { c = targetType.getFactory().Class().get(this.getClass()); } b = Substitution .substitute(targetType, this, getExpressionBlock(c)); return ((CtReturn<T>) b.getStatements().get(0)).getReturnedExpression(); }
public <R> void visitCtReturn(CtReturn<R> returnStatement) { enter(returnStatement); scan(returnStatement.getAnnotations()); scan(returnStatement.getReturnedExpression()); exit(returnStatement); }
public static boolean isGetter(CtMethod<?> method) { if (hasNoArguments(method) && numberOfStatements(method) == 1) { CtStatement statement = lastStatementOf(method); return isReturnStatement(statement) && isFieldAccess(((CtReturn<?>) statement).getReturnedExpression()); } return false; }
@SuppressWarnings("unchecked") public static <T> CtExpression<T> compileExpression( CtCodeSnippetExpression<T> expr) throws SnippetCompilationError { // create wrapping template Factory f = expr.getFactory(); CtClass<?> w = createWrapper(expr, f); String contents = w.toString(); build(f, contents); CtType<?> c = f.Type().get("Wrapper"); // Get the part we want CtMethod<T> wrapper = Query.getElements(c, new Filter<CtMethod<T>>() { public boolean matches(CtMethod<T> element) { return element.getSimpleName().equals("wrap"); } }).get(0); CtReturn<T> ret = (CtReturn<T>) wrapper.getBody().getStatements() .get(0); // Clean up (delete wrapper from factory) c.getPackage().getTypes().remove(c); return ret.getReturnedExpression(); }
public <R> void visitCtReturn(CtReturn<R> returnStatement) { CtReturn<R> r = returnStatement.getFactory().Core().createReturn(); r.setReturnedExpression(evaluate(r, returnStatement.getReturnedExpression())); setResult(r); flowEnded = true; }