public static void insertAfter(CtStatement target, CtStatementList statements) throws ParentNotInitializedException { CtElement e = target.getParent(); if (e instanceof CtExecutable) { throw new RuntimeException("cannot insert in this context (use insertEnd?)"); } new InsertVisitor(target, statements, InsertType.AFTER).scan(e); }
/** inserts all statements of `statementsToBeInserted` just before `target` */ public static void insertBefore(CtStatement target, CtStatementList statementsToBeInserted) throws ParentNotInitializedException { CtElement targetParent = target.getParent(); if (targetParent instanceof CtExecutable) { throw new SpoonException("cannot insert in this context (use insertEnd?)"); } try { if (target.getParent(CtConstructor.class) != null) { if (target instanceof CtInvocation && ((CtInvocation<?>) target).getExecutable().getSimpleName().startsWith(CtExecutableReference.CONSTRUCTOR_NAME)) { throw new SpoonException("cannot insert a statement before a super or this invocation."); } } } catch (ParentNotInitializedException ignore) { // no parent set somewhere } new InsertVisitor(target, statementsToBeInserted, InsertType.BEFORE).scan(targetParent); }
parent = element.getParent(); } catch (ParentNotInitializedException e) { return false;
/** write all non-implicit parts of a block, with special care for indentation */ public void writeIfOrLoopBlock(CtStatement block) { if (block != null) { if (!block.isImplicit() && (block instanceof CtBlock || block instanceof CtIf)) { printer.writeSpace(); } if (!(block instanceof CtBlock) && !(block instanceof CtIf)) { printer.incTab(); printer.writeln(); } writeStatement(block); if (!(block instanceof CtBlock) && !(block instanceof CtIf)) { printer.decTab().writeln(); } if (!block.isImplicit()) { if (!block.isParentInitialized() || (!(block.getParent() instanceof CtFor) && !(block.getParent() instanceof CtForEach) && !(block.getParent() instanceof CtIf))) { printer.writeSpace(); } } } else { printer.writeSeparator(";"); } } /**
private CtStatement getRightInsertionPoint(CtInvocation<?> invocation) { CtStatement currentPoint = invocation; while (! (currentPoint.getParent(CtStatement.class) instanceof CtBlock<?>) && ! (currentPoint instanceof CtBlock<?>)) { currentPoint = currentPoint.getParent(CtStatement.class); } return currentPoint; }
private boolean inWhileLoop(CtStatement stmt) { return stmt.getParent(CtWhile.class) != null; }
@Override public void process(CtStatement element) { if (!(element instanceof CtClass || element instanceof CtMethod) && (element.getParent() instanceof CtBlock)) { add(element); } }
@Override public void process(CtStatement ctStatement) { this.method = ctStatement.getParent(CtMethod.class).getSimpleName(); }
private boolean isElseIf(CtStatement original, CtStatement parentLine) { if (parentLine.getParent() instanceof CtIf) { CtStatement elseStatement = ((CtIf) parentLine.getParent()).getElseStatement(); if (elseStatement == original) { return true; } else if (elseStatement instanceof CtBlock) { CtBlock block = (CtBlock) elseStatement; if (block.isImplicit() && block.getStatement(0) == original) { return true; } } } if (parentLine.getParent() instanceof CtBlock) { return isElseIf(original, (CtStatement) parentLine.getParent()); } return false; }
@Override public void process(CtStatement element) { if (!(element instanceof CtBlock || element instanceof CtClass || element instanceof CtMethod || element instanceof CtTry || element instanceof CtCatch) && (element.getParent() instanceof CtBlock) && (!(element.toString().startsWith("super")) || ConfigurationProperties.getPropertyBool("manipulatesuper"))) { add(element); } }
private void addAtCorrectPlace(String id, CtStatement lastStmt, CtStatement assertStatement, CtStatement statementToBeAsserted) { if (id.endsWith("end")) { statementToBeAsserted.getParent(CtBlock.class).insertEnd(assertStatement); } else { lastStmt.insertAfter(assertStatement); } } }
private void replaceInvocationByLocalVariable(CtStatement invocationToBeReplaced, CtLocalVariable localVariable) { if (invocationToBeReplaced.getParent() instanceof CtBlock) { invocationToBeReplaced.replace(localVariable); } else { CtElement parent = invocationToBeReplaced.getParent(); while (!(parent.getParent() instanceof CtBlock)) { parent = invocationToBeReplaced.getParent(); } ((CtStatement) parent).insertBefore(localVariable); invocationToBeReplaced.replace(localVariable.getReference()); } }
public static void replace(CtStatement target, CtStatementList statements) throws ParentNotInitializedException { insertAfter(target, statements); CtElement e = target.getParent(); CtStatementList parentStatementList = (CtStatementList) e; parentStatementList.removeStatement(target); }
public static void insertAfter(CtStatement target, CtStatementList statements) throws ParentNotInitializedException { CtElement e = target.getParent(); if (e instanceof CtExecutable) { throw new RuntimeException("cannot insert in this context (use insertEnd?)"); } CtStatementList parentStatementList = (CtStatementList) e; int i = 0; for (CtStatement s : parentStatementList.getStatements()) { i++; if (s == target) { break; } } for (int j = statements.getStatements().size() - 1; j >= 0; j--) { CtStatement s = statements.getStatements().get(j); parentStatementList.getStatements().add(i, s); } }
@Override public boolean isToBeProcessed(CtStatement candidate) { CtClass parent = candidate.getParent(CtClass.class); if (parent == null || !parent.getQualifiedName().equals(this.location.getContainingClassName())) { return false; } return parent.getPosition().getLine() == location.getLineNumber(); }
public static void insertBeforeUnderSameParent(CtStatement toBeInserted, CtStatement insertionPoint) { CtElement parent; if (isBlock(insertionPoint)) { CtBlock<?> block = (CtBlock<?>) insertionPoint; block.insertBegin(toBeInserted); parent = block; } else { insertionPoint.insertBefore(toBeInserted); parent = insertionPoint.getParent(); } setParent(parent, toBeInserted); }
public static void insertAfterUnderSameParent(CtStatement toBeInserted, CtStatement insertionPoint) { CtElement parent; if (isBlock(insertionPoint)) { CtBlock<?> block = (CtBlock<?>) insertionPoint; block.insertEnd(toBeInserted); parent = block; } else { insertionPoint.insertAfter(toBeInserted); parent = insertionPoint.getParent(); } setParent(parent, toBeInserted); }
private Filter<CtAssignment<?, ?>> initializationAssignmentsFilterFor(CtVariable<?> variable, CtStatement statement) { VariableAssignmentFilter variableAssignment = new VariableAssignmentFilter(variable); BeforeLocationFilter<CtAssignment<?, ?>> beforeLocation = new BeforeLocationFilter(CtAssignment.class, statement.getPosition()); InBlockFilter<CtAssignment<?, ?>> inVariableDeclarationBlock = new InBlockFilter(CtAssignment.class, asList(variable.getParent(CtBlock.class))); InBlockFilter<CtAssignment<?, ?>> inStatementBlock = new InBlockFilter(CtAssignment.class, asList(statement.getParent(CtBlock.class))); Filter<CtAssignment<?, ?>> inBlockFilter = new CompositeFilter(FilteringOperator.UNION, inStatementBlock, inVariableDeclarationBlock); return new CompositeFilter(FilteringOperator.INTERSECTION, variableAssignment, beforeLocation, inBlockFilter); }
public static boolean isLastStatementOfMethod(CtStatement statement) { CtElement statementParent = statement.getParent(); if (!isStatementList(statementParent)) { return isLastStatementOfMethod((CtStatement) statementParent); } CtStatementList block = (CtStatementList) statementParent; if (isLastStatementOf(block, statement)) { CtElement blockParent = block.getParent(); if (isStatement(blockParent)) { return isLastStatementOfMethod((CtStatement) blockParent); } else { return isMethod(blockParent); } } return false; }
@Override public void process(CtStatement element) { if (element instanceof CtIf) { add(((CtIf) element).getCondition()); } else if (element instanceof CtFor) { add(((CtFor) element).getExpression()); } else if (element instanceof CtWhile) { add(((CtWhile) element).getLoopingExpression()); } else if (element instanceof CtDo) { add(((CtDo) element).getLoopingExpression()); } else if (element instanceof CtThrow) { add(((CtThrow) element).getThrownExpression()); } else if (element instanceof CtInvocation && (element.getParent() instanceof CtBlock)) { add(element); } else if (element instanceof CtAssignment || element instanceof CtConstructorCall || element instanceof CtCFlowBreak || element instanceof CtLocalVariable) { add(element); } }