/*
* @see ASTVisitor#visit(Block)
*/
public boolean visit(Block node) {
this.fBuffer.append("{"); // $NON-NLS-1$
for (Iterator it = node.statements().iterator(); it.hasNext(); ) {
Statement s = (Statement) it.next();
s.accept(this);
}
this.fBuffer.append("}"); // $NON-NLS-1$
return false;
}
private void convertBody(
Statement body,
final IBinding indexBinding,
final IBinding arrayBinding,
final String parameterName,
final ASTRewrite rewrite,
final TextEditGroup editGroup,
final LinkedProposalPositionGroup pg) {
final AST ast = body.getAST();
body.accept(
new GenericVisitor() {
@Override
public boolean visit(ArrayAccess node) {
IBinding binding = getBinding(node.getArray());
if (arrayBinding.equals(binding)) {
IBinding index = getBinding(node.getIndex());
if (indexBinding.equals(index)) {
replaceAccess(node);
}
}
return super.visit(node);
}
private void replaceAccess(ASTNode node) {
if (fElementDeclaration != null
&& node.getLocationInParent() == VariableDeclarationFragment.INITIALIZER_PROPERTY) {
VariableDeclarationFragment fragment = (VariableDeclarationFragment) node.getParent();
IBinding targetBinding = fragment.getName().resolveBinding();
if (targetBinding != null) {
VariableDeclarationStatement statement =
(VariableDeclarationStatement) fragment.getParent();
if (statement.fragments().size() == 1) {
rewrite.remove(statement, editGroup);
} else {
ListRewrite listRewrite =
rewrite.getListRewrite(
statement, VariableDeclarationStatement.FRAGMENTS_PROPERTY);
listRewrite.remove(fragment, editGroup);
}
} else {
SimpleName name = ast.newSimpleName(parameterName);
rewrite.replace(node, name, editGroup);
pg.addPosition(rewrite.track(name), true);
}
} else {
SimpleName name = ast.newSimpleName(parameterName);
rewrite.replace(node, name, editGroup);
pg.addPosition(rewrite.track(name), true);
}
}
});
}
private List<Statement> getNextSiblings(Statement node) {
if (node.getParent() instanceof Block) {
final List<Statement> stmts = asList((Statement) node.getParent());
final int indexOfNode = stmts.indexOf(node);
final int siblingIndex = indexOfNode + 1;
if (0 <= siblingIndex && siblingIndex < stmts.size()) {
return stmts.subList(siblingIndex, stmts.size());
}
}
return Collections.emptyList();
}
/*
* @see ASTVisitor#visit(SwitchStatement)
*/
public boolean visit(SwitchStatement node) {
this.fBuffer.append("switch ("); // $NON-NLS-1$
node.getExpression().accept(this);
this.fBuffer.append(") "); // $NON-NLS-1$
this.fBuffer.append("{"); // $NON-NLS-1$
for (Iterator it = node.statements().iterator(); it.hasNext(); ) {
Statement s = (Statement) it.next();
s.accept(this);
}
this.fBuffer.append("}"); // $NON-NLS-1$
return false;
}
private boolean lastStmtIsThrowOrReturn(Statement stmt) {
final List<Statement> stmts = asList(stmt);
if (stmts.isEmpty()) {
return false;
}
final Statement lastStmt = stmts.get(stmts.size() - 1);
switch (lastStmt.getNodeType()) {
case RETURN_STATEMENT:
case THROW_STATEMENT:
return true;
case IF_STATEMENT:
final IfStatement ifStmt = (IfStatement) lastStmt;
final Statement thenStmt = ifStmt.getThenStatement();
final Statement elseStmt = ifStmt.getElseStatement();
return lastStmtIsThrowOrReturn(thenStmt)
&& (elseStmt == null || lastStmtIsThrowOrReturn(elseStmt));
default:
return false;
}
}
private ASTRewrite doAddLocal(CompilationUnit cu) {
AST ast = cu.getAST();
Block body;
BodyDeclaration decl = ASTResolving.findParentBodyDeclaration(fOriginalNode);
IBinding targetContext = null;
if (decl instanceof MethodDeclaration) {
body = (((MethodDeclaration) decl).getBody());
targetContext = ((MethodDeclaration) decl).resolveBinding();
} else if (decl instanceof Initializer) {
body = (((Initializer) decl).getBody());
targetContext = Bindings.getBindingOfParentType(decl);
} else {
return null;
}
ASTRewrite rewrite = ASTRewrite.create(ast);
ImportRewrite imports = createImportRewrite((CompilationUnit) decl.getRoot());
ImportRewriteContext importRewriteContext =
new ContextSensitiveImportRewriteContext(decl, imports);
SimpleName[] names = getAllReferences(body);
ASTNode dominant = getDominantNode(names);
Statement dominantStatement = ASTResolving.findParentStatement(dominant);
if (ASTNodes.isControlStatementBody(dominantStatement.getLocationInParent())) {
dominantStatement = (Statement) dominantStatement.getParent();
}
SimpleName node = names[0];
if (isAssigned(dominantStatement, node)) {
// x = 1; -> int x = 1;
Assignment assignment = (Assignment) node.getParent();
// trick to avoid comment removal around the statement: keep the expression statement
// and replace the assignment with an VariableDeclarationExpression
VariableDeclarationFragment newDeclFrag = ast.newVariableDeclarationFragment();
VariableDeclarationExpression newDecl = ast.newVariableDeclarationExpression(newDeclFrag);
newDecl.setType(evaluateVariableType(ast, imports, importRewriteContext, targetContext));
Expression placeholder = (Expression) rewrite.createCopyTarget(assignment.getRightHandSide());
newDeclFrag.setInitializer(placeholder);
newDeclFrag.setName(ast.newSimpleName(node.getIdentifier()));
rewrite.replace(assignment, newDecl, null);
addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(newDeclFrag.getName()), true, KEY_NAME);
setEndPosition(rewrite.track(assignment.getParent()));
return rewrite;
} else if ((dominant != dominantStatement) && isForStatementInit(dominantStatement, node)) {
// for (x = 1;;) ->for (int x = 1;;)
Assignment assignment = (Assignment) node.getParent();
VariableDeclarationFragment frag = ast.newVariableDeclarationFragment();
VariableDeclarationExpression expression = ast.newVariableDeclarationExpression(frag);
frag.setName(ast.newSimpleName(node.getIdentifier()));
Expression placeholder = (Expression) rewrite.createCopyTarget(assignment.getRightHandSide());
frag.setInitializer(placeholder);
expression.setType(evaluateVariableType(ast, imports, importRewriteContext, targetContext));
rewrite.replace(assignment, expression, null);
addLinkedPosition(rewrite.track(expression.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(frag.getName()), true, KEY_NAME);
setEndPosition(rewrite.track(expression));
return rewrite;
} else if ((dominant != dominantStatement)
&& isEnhancedForStatementVariable(dominantStatement, node)) {
// for (x: collectionOfT) -> for (T x: collectionOfT)
EnhancedForStatement enhancedForStatement = (EnhancedForStatement) dominantStatement;
SingleVariableDeclaration parameter = enhancedForStatement.getParameter();
Expression expression = enhancedForStatement.getExpression();
SimpleName newName = (SimpleName) rewrite.createMoveTarget(node);
rewrite.set(parameter, SingleVariableDeclaration.NAME_PROPERTY, newName, null);
ITypeBinding elementBinding = null;
ITypeBinding typeBinding = expression.resolveTypeBinding();
if (typeBinding != null) {
if (typeBinding.isArray()) {
elementBinding = typeBinding.getElementType();
} else {
ITypeBinding iterable =
Bindings.findTypeInHierarchy(typeBinding, "java.lang.Iterable"); // $NON-NLS-1$
if (iterable != null) {
ITypeBinding[] typeArguments = iterable.getTypeArguments();
if (typeArguments.length == 1) {
elementBinding = typeArguments[0];
elementBinding = Bindings.normalizeForDeclarationUse(elementBinding, ast);
}
}
}
}
Type type;
if (elementBinding != null) {
type = imports.addImport(elementBinding, ast, importRewriteContext);
} else {
type = ast.newSimpleType(ast.newSimpleName("Object")); // $NON-NLS-1$
}
rewrite.set(parameter, SingleVariableDeclaration.TYPE_PROPERTY, type, null);
addLinkedPosition(rewrite.track(type), false, KEY_TYPE);
addLinkedPosition(rewrite.track(newName), true, KEY_NAME);
setEndPosition(rewrite.track(expression));
return rewrite;
}
// foo(x) -> int x; foo(x)
VariableDeclarationFragment newDeclFrag = ast.newVariableDeclarationFragment();
VariableDeclarationStatement newDecl = ast.newVariableDeclarationStatement(newDeclFrag);
newDeclFrag.setName(ast.newSimpleName(node.getIdentifier()));
newDecl.setType(evaluateVariableType(ast, imports, importRewriteContext, targetContext));
// newDeclFrag.setInitializer(ASTNodeFactory.newDefaultExpression(ast, newDecl.getType(), 0));
addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(node), true, KEY_NAME);
addLinkedPosition(rewrite.track(newDeclFrag.getName()), false, KEY_NAME);
Statement statement = dominantStatement;
List<? extends ASTNode> list = ASTNodes.getContainingList(statement);
while (list == null
&& statement.getParent() instanceof Statement) { // parent must be if, for or while
statement = (Statement) statement.getParent();
list = ASTNodes.getContainingList(statement);
}
if (list != null) {
ASTNode parent = statement.getParent();
StructuralPropertyDescriptor childProperty = statement.getLocationInParent();
if (childProperty.isChildListProperty()) {
rewrite
.getListRewrite(parent, (ChildListPropertyDescriptor) childProperty)
.insertBefore(newDecl, statement, null);
return rewrite;
} else {
return null;
}
}
return rewrite;
}
/**
* Copies the leading comment from the given statement.
*
* @param source the statement that supplies the leading comment
* @since 2.1
*/
void copyLeadingComment(Statement source) {
setLeadingComment(source.getLeadingComment());
}
/*
* returns false iff
* <ul>
* <li><code>indexBinding</code> is used for anything else then accessing
* an element of <code>arrayBinding</code></li>
* <li><code>arrayBinding</code> is assigned</li>
* <li>an element of <code>arrayBinding</code> is assigned</li>
* <li><code>lengthBinding</code> is referenced</li>
* </ul>
* within <code>body</code>
*/
private boolean validateBody(ForStatement statement) {
Statement body = statement.getBody();
try {
body.accept(
new GenericVisitor() {
/** {@inheritDoc} */
@Override
protected boolean visitNode(ASTNode node) {
if (node instanceof Name) {
Name name = (Name) node;
IBinding nameBinding = name.resolveBinding();
if (nameBinding == null) throw new InvalidBodyError();
if (nameBinding.equals(fIndexBinding)) {
if (node.getLocationInParent() != ArrayAccess.INDEX_PROPERTY)
throw new InvalidBodyError();
ArrayAccess arrayAccess = (ArrayAccess) node.getParent();
Expression array = arrayAccess.getArray();
if (array instanceof QualifiedName) {
if (!(fArrayAccess instanceof QualifiedName)) throw new InvalidBodyError();
IBinding varBinding1 = ((QualifiedName) array).getQualifier().resolveBinding();
if (varBinding1 == null) throw new InvalidBodyError();
IBinding varBinding2 =
((QualifiedName) fArrayAccess).getQualifier().resolveBinding();
if (!varBinding1.equals(varBinding2)) throw new InvalidBodyError();
} else if (array instanceof FieldAccess) {
Expression arrayExpression = ((FieldAccess) array).getExpression();
if (arrayExpression instanceof ThisExpression) {
if (fArrayAccess instanceof FieldAccess) {
Expression arrayAccessExpression =
((FieldAccess) fArrayAccess).getExpression();
if (!(arrayAccessExpression instanceof ThisExpression))
throw new InvalidBodyError();
} else if (fArrayAccess instanceof QualifiedName) {
throw new InvalidBodyError();
}
} else {
if (!(fArrayAccess instanceof FieldAccess)) throw new InvalidBodyError();
Expression arrayAccessExpression =
((FieldAccess) fArrayAccess).getExpression();
if (!arrayExpression.subtreeMatch(
new JdtASTMatcher(), arrayAccessExpression)) {
throw new InvalidBodyError();
}
}
} else {
if (fArrayAccess instanceof QualifiedName) {
throw new InvalidBodyError();
}
if (fArrayAccess instanceof FieldAccess) {
Expression arrayAccessExpression =
((FieldAccess) fArrayAccess).getExpression();
if (!(arrayAccessExpression instanceof ThisExpression))
throw new InvalidBodyError();
}
}
IBinding binding = getBinding(array);
if (binding == null) throw new InvalidBodyError();
if (!fArrayBinding.equals(binding)) throw new InvalidBodyError();
} else if (nameBinding.equals(fArrayBinding)) {
if (isAssigned(node)) throw new InvalidBodyError();
} else if (nameBinding.equals(fLengthBinding)) {
throw new InvalidBodyError();
} else if (fElementDeclaration != null
&& nameBinding.equals(fElementDeclaration.getName().resolveBinding())) {
if (isAssigned(node)) fElementDeclaration = null;
}
}
return true;
}
private boolean isAssigned(ASTNode current) {
while (current != null && !(current instanceof Statement)) {
if (current.getLocationInParent() == Assignment.LEFT_HAND_SIDE_PROPERTY)
return true;
if (current instanceof PrefixExpression) return true;
if (current instanceof PostfixExpression) return true;
current = current.getParent();
}
return false;
}
@Override
public boolean visit(ArrayAccess node) {
if (fElementDeclaration != null) return super.visit(node);
IBinding binding = getBinding(node.getArray());
if (fArrayBinding.equals(binding)) {
IBinding index = getBinding(node.getIndex());
if (fIndexBinding.equals(index)) {
if (node.getLocationInParent()
== VariableDeclarationFragment.INITIALIZER_PROPERTY) {
fElementDeclaration = (VariableDeclarationFragment) node.getParent();
}
}
}
return super.visit(node);
}
});
} catch (InvalidBodyError e) {
return false;
}
return true;
}
