static List<? extends CtElement> bodyToStatements(CtStatement statementOrBlock) { if (statementOrBlock instanceof CtBlock) { return ((CtBlock<?>) statementOrBlock).getStatements(); } return Collections.singletonList(statementOrBlock); }
private CtStatement getElseIfStatement(CtStatement elseStmt) { if (elseStmt instanceof CtBlock<?>) { CtBlock<?> block = (CtBlock<?>) elseStmt; if (block.isImplicit()) { List<CtStatement> stmts = block.getStatements(); if (stmts.size() == 1) { if (stmts.get(0) instanceof CtIf) { return stmts.get(0); } } } } return elseStmt; }
@Override void insertFromFirstStatement(CtBlock<?> block, CtStatement target, CtStatementList statementsToBeInserted) { final List<CtStatement> copy = new ArrayList<>(block.getStatements()); int indexOfTargetElement = indexOfReference(block.getStatements(), target); for (CtStatement ctStatement : statementsToBeInserted) { copy.add(indexOfTargetElement++, ctStatement); } //remove statements from the `statementsToBeInserted` before they are added to spoon model //note: one element MUST NOT be part of two models. statementsToBeInserted.setStatements(null); block.setStatements(copy); }
@Override void insertFromFirstStatement(CtBlock<?> block, CtStatement target, CtStatementList statementsToBeInserted) { final List<CtStatement> copy = new ArrayList<>(block.getStatements()); int indexOfTargetElement = indexOfReference(block.getStatements(), target); for (CtStatement s : statementsToBeInserted) { copy.add(++indexOfTargetElement, s); } //remove statements from the `statementsToBeInserted` before they are added to spoon model //note: one element MUST NOT be part of two models. statementsToBeInserted.setStatements(null); block.setStatements(copy); }
/** * 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(); }
/** * 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())); }
/** * Sets a template model from body of the method of template type selected by filter * @param filter the {@link Filter} whose match defines to be used {@link CtMethod} */ private void setBodyOfMethod(Filter<CtMethod<?>> filter) { CtBlock<?> body = getOneByFilter(filter).getBody(); setElements(body.getStatements()); }
@Override public <T> void getValueAs(Factory factory, ResultHolder<T> result, ImmutableMap parameters) { //get raw parameter value Object rawValue = getValue(parameters); if (isMultiple() && rawValue instanceof CtBlock<?>) { /* * The CtBlock of this parameter is just implicit container of list of statements. * Convert it to list here, so further code see list and not the single CtBlock element */ rawValue = ((CtBlock<?>) rawValue).getStatements(); } convertValue(factory, result, rawValue); }
@Override public CtStatement apply(CtType<?> targetType) { CtClass<?> c = Substitution.getTemplateCtClass(targetType, this); // we substitute the first statement of method statement CtStatement patternModel = c.getMethod("statement").getBody().getStatements().get(0); List<CtStatement> statements = TemplateBuilder.createPattern(patternModel, this) .setAddGeneratedBy(isAddGeneratedBy()) .substituteList(c.getFactory(), targetType, CtStatement.class); if (statements.size() != 1) { throw new IllegalStateException(); } return statements.get(0); }
/** * Creates a new statement list from an existing block. */ public <R> CtStatementList createStatementList(CtBlock<R> block) { CtStatementList l = factory.Core().createStatementList(); for (CtStatement s : block.getStatements()) { l.addStatement(s.clone()); } return l; }
public <R> void visitCtBlock(final spoon.reflect.code.CtBlock<R> block) { spoon.reflect.code.CtBlock other = ((spoon.reflect.code.CtBlock) (this.stack.peek())); enter(block); biScan(spoon.reflect.path.CtRole.ANNOTATION, block.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.STATEMENT, block.getStatements(), other.getStatements()); biScan(spoon.reflect.path.CtRole.COMMENT, block.getComments(), other.getComments()); exit(block); }
public <R> void visitCtBlock(final CtBlock<R> block) { enter(block); scan(CtRole.ANNOTATION, block.getAnnotations()); scan(CtRole.STATEMENT, block.getStatements()); scan(CtRole.COMMENT, block.getComments()); exit(block); }
@java.lang.Override public <R> void visitCtBlock(final spoon.reflect.code.CtBlock<R> block) { replaceInListIfExist(block.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(block)); replaceInListIfExist(block.getStatements(), new spoon.support.visitor.replace.ReplacementVisitor.CtStatementListStatementsReplaceListener(block)); replaceInListIfExist(block.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(block)); }
private static CtStatement internalCompileStatement(CtElement st, CtTypeReference returnType) { Factory f = st.getFactory(); String contents = createWrapperContent(st, f, returnType); build(f, contents); CtType<?> c = f.Type().get(WRAPPER_CLASS_NAME); // Get the part we want CtMethod<?> wrapper = c.getMethod(WRAPPER_METHOD_NAME); List<CtStatement> statements = wrapper.getBody().getStatements(); CtStatement ret = statements.get(statements.size() - 1); // Clean up c.getPackage().removeType(c); //disconnect element from the parent, so it can be added to another model ret.delete(); ret.setParent(null); if (ret instanceof CtClass) { CtClass klass = (CtClass) ret; ret.getFactory().Package().getRootPackage().addType(klass); klass.setSimpleName(klass.getSimpleName().replaceAll("^[0-9]*", "")); } return ret; }
public CtStatementList getSubstitution(CtType<?> targetType) { CtClass<?> c; CtBlock<?> b; c = targetType.getFactory().Class().get(this.getClass()); if (c == null) { c = targetType.getFactory().Class().get(this.getClass()); } CtStatementList l = targetType.getFactory().Core().createStatementList(); if (this instanceof Template) { b = Substitution.substitute(targetType, (Template<?>) this, c.getMethod("statements").getBody()); } else { b = c.getMethod("statements").getBody().clone(); } l.setStatements(b.getStatements()); return l; }
@Override public <R> void visitCtBlock(CtBlock<R> block) { CtBlock<?> b = block.getFactory().Core().createBlock(); for (CtStatement s : block.getStatements()) { CtElement res = evaluate(s); if (res != null) { if (res instanceof CtStatement) { b.addStatement((CtStatement) res); } else { //the context expects statement. We cannot simplify in this case b.addStatement(s.clone()); } } // do not copy unreachable statements if (flowEnded) { break; } } setResult(b); }
if (m.getBody().getPosition().isValidPosition()) { if (m.getBody().getPosition().getCompilationUnit() == sourceCompilationUnit) { if (m.getBody().getStatements().isEmpty() || !(m.getBody().getStatements().get(m.getBody().getStatements().size() - 1) instanceof CtReturn)) { getPrinterHelper().putLineNumberMapping(m.getBody().getPosition().getEndLine());
public <R> void visitCtBlock(final spoon.reflect.code.CtBlock<R> block) { spoon.reflect.code.CtBlock<R> aCtBlock = block.getFactory().Core().createBlock(); this.builder.copy(block, aCtBlock); aCtBlock.setAnnotations(this.cloneHelper.clone(block.getAnnotations())); aCtBlock.setStatements(this.cloneHelper.clone(block.getStatements())); aCtBlock.setComments(this.cloneHelper.clone(block.getComments())); this.cloneHelper.tailor(block, aCtBlock); this.other = aCtBlock; }
ASTPair pair = context.stack.peek(); CtBlock<?> block = (CtBlock<?>) pair.element; if (block.getStatements().size() == 1) { CtStatement childStmt = block.getStatement(0); if (childStmt.getLabel() == null) {
@Override public <R> void visitCtBlock(CtBlock<R> block) { enterCtStatement(block); if (!block.isImplicit()) { printer.writeSeparator("{"); } printer.incTab(); for (CtStatement statement : block.getStatements()) { if (!statement.isImplicit()) { printer.writeln(); elementPrinterHelper.writeStatement(statement); } } printer.decTab(); getPrinterHelper().adjustEndPosition(block); if (env.isPreserveLineNumbers()) { if (!block.isImplicit()) { printer.writeSeparator("}"); } } else { printer.writeln(); if (!block.isImplicit()) { printer.writeSeparator("}"); } } exitCtStatement(block); }