public static void getInvalidQualificationProposals(
IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
ASTNode node = problem.getCoveringNode(context.getASTRoot());
if (!(node instanceof Name)) {
return;
}
Name name = (Name) node;
IBinding binding = name.resolveBinding();
if (!(binding instanceof ITypeBinding)) {
return;
}
ITypeBinding typeBinding = (ITypeBinding) binding;
AST ast = node.getAST();
ASTRewrite rewrite = ASTRewrite.create(ast);
rewrite.replace(name, ast.newName(typeBinding.getQualifiedName()), null);
String label = CorrectionMessages.JavadocTagsSubProcessor_qualifylinktoinner_description;
Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
ASTRewriteCorrectionProposal proposal =
new ASTRewriteCorrectionProposal(
label,
context.getCompilationUnit(),
rewrite,
IProposalRelevance.QUALIFY_INNER_TYPE_NAME,
image);
proposals.add(proposal);
}
/** Renames the main type in <code>cu</code>. */
private void updateTypeName(
ICompilationUnit cu,
CompilationUnit astCU,
String oldName,
String newName,
ASTRewrite rewriter)
throws JavaModelException {
if (newName != null) {
String oldTypeName = Util.getNameWithoutJavaLikeExtension(oldName);
String newTypeName = Util.getNameWithoutJavaLikeExtension(newName);
AST ast = astCU.getAST();
// update main type name
IType[] types = cu.getTypes();
for (int i = 0, max = types.length; i < max; i++) {
IType currentType = types[i];
if (currentType.getElementName().equals(oldTypeName)) {
AbstractTypeDeclaration typeNode =
(AbstractTypeDeclaration) ((JavaElement) currentType).findNode(astCU);
if (typeNode != null) {
// rename type
rewriter.replace(typeNode.getName(), ast.newSimpleName(newTypeName), null);
// rename constructors
Iterator bodyDeclarations = typeNode.bodyDeclarations().iterator();
while (bodyDeclarations.hasNext()) {
Object bodyDeclaration = bodyDeclarations.next();
if (bodyDeclaration instanceof MethodDeclaration) {
MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
if (methodDeclaration.isConstructor()) {
SimpleName methodName = methodDeclaration.getName();
if (methodName.getIdentifier().equals(oldTypeName)) {
rewriter.replace(methodName, ast.newSimpleName(newTypeName), null);
}
}
}
}
}
}
}
}
}
private Delta deduplicate(CompilationUnit root, ASTRewrite rewrite, Cause cause) {
final List<ASTNode> nodes = cause.getAffectedNodes();
final int size = nodes.size();
final int cloneNumber = size == 0 ? size : size - 1; // minus the original declaration
if (cloneNumber == 0) {
throw new RuntimeException("calling deduplicate() when there are no detected clones");
} else if (cloneNumber >= 1) {
// NOTE: THIS WORKS ONLY AT METHOD LEVEL, other forms of duplication will
// will be ignored.
// The strategy this code follows to perform deduplication is the following:
// per duplicated method declaration, find all of its invocations. Then
// rename each found invocation using the name of the original method declaration.
// After that, remove the duplicated method declaration.
if (AstUtil.isOfType(MethodDeclaration.class, nodes.get(0))) {
final MethodDeclaration original = AstUtil.exactCast(MethodDeclaration.class, nodes.get(0));
final Iterable<ASTNode> rest = Iterables.skip(nodes, 1);
for (ASTNode eachClone : rest) {
final MethodDeclaration duplicate = AstUtil.exactCast(MethodDeclaration.class, eachClone);
final MethodDeclaration copied =
AstUtil.copySubtree(MethodDeclaration.class, root.getAST(), duplicate);
final boolean sameReturn = sameReturnType(original, copied);
if (!sameReturn) { // all or none. We don't do partial deduplication
throw new RuntimeException(
"automatic deduplication cannot be done on methods "
+ "with different return types; please consider "
+ "manual deduplication.");
}
final MethodInvocationVisitor invokesOfDuplication =
new MethodInvocationVisitor(copied.getName());
root.accept(invokesOfDuplication);
final Set<MethodInvocation> invokes = invokesOfDuplication.getMethodInvocations();
for (MethodInvocation each : invokes) {
final MethodInvocation copiedInvoke =
AstUtil.copySubtree(MethodInvocation.class, root.getAST(), each);
copiedInvoke.setName(root.getAST().newSimpleName(original.getName().getIdentifier()));
rewrite.replace(each, copiedInvoke, null);
}
rewrite.remove(duplicate, null);
}
}
}
return createDelta(root, rewrite);
}
/** {@inheritDoc} */
@Override
public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel positionGroups)
throws CoreException {
TextEditGroup group =
createTextEditGroup(FixMessages.Java50Fix_ConvertToEnhancedForLoop_description, cuRewrite);
ASTRewrite rewrite = cuRewrite.getASTRewrite();
TightSourceRangeComputer rangeComputer;
if (rewrite.getExtendedSourceRangeComputer() instanceof TightSourceRangeComputer) {
rangeComputer = (TightSourceRangeComputer) rewrite.getExtendedSourceRangeComputer();
} else {
rangeComputer = new TightSourceRangeComputer();
}
rangeComputer.addTightSourceNode(getForStatement());
rewrite.setTargetSourceRangeComputer(rangeComputer);
Statement statement = convert(cuRewrite, group, positionGroups);
rewrite.replace(getForStatement(), statement, group);
}
@Override
protected void repairBug(ASTRewrite rewrite, CompilationUnit workingUnit, BugInstance bug)
throws BugResolutionException {
assert rewrite != null;
assert workingUnit != null;
assert bug != null;
InfixExpression oddnessCheck =
findOddnessCheck(getASTNode(workingUnit, bug.getPrimarySourceLineAnnotation()));
if (oddnessCheck == null) {
throw new BugResolutionException(
"No matching oddness check found at the specified source line.");
}
Expression numberExpression = findNumberExpression(oddnessCheck);
if (numberExpression == null) {
throw new BugResolutionException();
}
InfixExpression correctOddnessCheck = createCorrectOddnessCheck(rewrite, numberExpression);
rewrite.replace(oddnessCheck, correctOddnessCheck, null);
}
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;
}
/*(non-Javadoc)
* @see org.eclipse.jdt.internal.ui.text.correction.ASTRewriteCorrectionProposal#getRewrite()
*/
@Override
protected ASTRewrite getRewrite() {
AST ast = fMethodDecl.getAST();
ITypeBinding returnBinding = getReturnTypeBinding();
if (fExistingReturn != null) {
ASTRewrite rewrite = ASTRewrite.create(ast);
Expression expression =
evaluateReturnExpressions(ast, returnBinding, fExistingReturn.getStartPosition());
if (expression != null) {
rewrite.set(fExistingReturn, ReturnStatement.EXPRESSION_PROPERTY, expression, null);
addLinkedPosition(rewrite.track(expression), true, RETURN_EXPRESSION_KEY);
}
return rewrite;
} else {
ASTRewrite rewrite = ASTRewrite.create(ast);
Block block = fMethodDecl.getBody();
List<Statement> statements = block.statements();
int nStatements = statements.size();
ASTNode lastStatement = null;
if (nStatements > 0) {
lastStatement = statements.get(nStatements - 1);
}
if (returnBinding != null
&& lastStatement instanceof ExpressionStatement
&& lastStatement.getNodeType() != ASTNode.ASSIGNMENT) {
Expression expression = ((ExpressionStatement) lastStatement).getExpression();
ITypeBinding binding = expression.resolveTypeBinding();
if (binding != null && binding.isAssignmentCompatible(returnBinding)) {
Expression placeHolder = (Expression) rewrite.createMoveTarget(expression);
ReturnStatement returnStatement = ast.newReturnStatement();
returnStatement.setExpression(placeHolder);
rewrite.replace(lastStatement, returnStatement, null);
return rewrite;
}
}
int offset;
if (lastStatement == null) {
offset = block.getStartPosition() + 1;
} else {
offset = lastStatement.getStartPosition() + lastStatement.getLength();
}
ReturnStatement returnStatement = ast.newReturnStatement();
Expression expression = evaluateReturnExpressions(ast, returnBinding, offset);
returnStatement.setExpression(expression);
rewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY).insertLast(returnStatement, null);
addLinkedPosition(
rewrite.track(returnStatement.getExpression()), true, RETURN_EXPRESSION_KEY);
return rewrite;
}
}
private void createTryCatchStatement(org.eclipse.jdt.core.IBuffer buffer, String lineDelimiter)
throws CoreException {
List<Statement> result = new ArrayList<>(1);
TryStatement tryStatement = getAST().newTryStatement();
ITypeBinding[] exceptions = fAnalyzer.getExceptions();
ImportRewriteContext context =
new ContextSensitiveImportRewriteContext(
fAnalyzer.getEnclosingBodyDeclaration(), fImportRewrite);
if (!fIsMultiCatch) {
for (int i = 0; i < exceptions.length; i++) {
ITypeBinding exception = exceptions[i];
CatchClause catchClause = getAST().newCatchClause();
tryStatement.catchClauses().add(catchClause);
SingleVariableDeclaration decl = getAST().newSingleVariableDeclaration();
String varName = StubUtility.getExceptionVariableName(fCUnit.getJavaProject());
String name = fScope.createName(varName, false);
decl.setName(getAST().newSimpleName(name));
Type type = fImportRewrite.addImport(exception, getAST(), context);
decl.setType(type);
catchClause.setException(decl);
Statement st = getCatchBody(ASTNodes.getQualifiedTypeName(type), name, lineDelimiter);
if (st != null) {
catchClause.getBody().statements().add(st);
}
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_TYPE + i, true)
.addPosition(fRewriter.track(decl.getType()), i == 0);
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_NAME + i, true)
.addPosition(fRewriter.track(decl.getName()), false);
}
} else {
List<ITypeBinding> filteredExceptions = filterSubtypeExceptions(exceptions);
CatchClause catchClause = getAST().newCatchClause();
SingleVariableDeclaration decl = getAST().newSingleVariableDeclaration();
String varName = StubUtility.getExceptionVariableName(fCUnit.getJavaProject());
String name = fScope.createName(varName, false);
decl.setName(getAST().newSimpleName(name));
UnionType unionType = getAST().newUnionType();
List<Type> types = unionType.types();
int i = 0;
for (ITypeBinding exception : filteredExceptions) {
Type type = fImportRewrite.addImport(exception, getAST(), context);
types.add(type);
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_TYPE + i, true)
.addPosition(fRewriter.track(type), i == 0);
i++;
}
decl.setType(unionType);
catchClause.setException(decl);
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_NAME + 0, true)
.addPosition(fRewriter.track(decl.getName()), false);
Statement st = getCatchBody("Exception", name, lineDelimiter); // $NON-NLS-1$
if (st != null) {
catchClause.getBody().statements().add(st);
}
tryStatement.catchClauses().add(catchClause);
}
List<ASTNode> variableDeclarations = getSpecialVariableDeclarationStatements();
ListRewrite statements =
fRewriter.getListRewrite(tryStatement.getBody(), Block.STATEMENTS_PROPERTY);
boolean selectedNodeRemoved = false;
ASTNode expressionStatement = null;
for (int i = 0; i < fSelectedNodes.length; i++) {
ASTNode node = fSelectedNodes[i];
if (node instanceof VariableDeclarationStatement && variableDeclarations.contains(node)) {
AST ast = getAST();
VariableDeclarationStatement statement = (VariableDeclarationStatement) node;
// Create a copy and remove the initializer
VariableDeclarationStatement copy =
(VariableDeclarationStatement) ASTNode.copySubtree(ast, statement);
List<IExtendedModifier> modifiers = copy.modifiers();
for (Iterator<IExtendedModifier> iter = modifiers.iterator(); iter.hasNext(); ) {
IExtendedModifier modifier = iter.next();
if (modifier.isModifier()
&& Modifier.isFinal(((Modifier) modifier).getKeyword().toFlagValue())) {
iter.remove();
}
}
List<VariableDeclarationFragment> fragments = copy.fragments();
for (Iterator<VariableDeclarationFragment> iter = fragments.iterator(); iter.hasNext(); ) {
VariableDeclarationFragment fragment = iter.next();
fragment.setInitializer(null);
}
CompilationUnit root = (CompilationUnit) statement.getRoot();
int extendedStart = root.getExtendedStartPosition(statement);
// we have a leading comment and the comment is covered by the selection
if (extendedStart != statement.getStartPosition()
&& extendedStart >= fSelection.getOffset()) {
String commentToken =
buffer.getText(extendedStart, statement.getStartPosition() - extendedStart);
commentToken = Strings.trimTrailingTabsAndSpaces(commentToken);
Type type = statement.getType();
String typeName = buffer.getText(type.getStartPosition(), type.getLength());
copy.setType(
(Type)
fRewriter.createStringPlaceholder(commentToken + typeName, type.getNodeType()));
}
result.add(copy);
// convert the fragments into expression statements
fragments = statement.fragments();
if (!fragments.isEmpty()) {
List<ExpressionStatement> newExpressionStatements = new ArrayList<>();
for (Iterator<VariableDeclarationFragment> iter = fragments.iterator();
iter.hasNext(); ) {
VariableDeclarationFragment fragment = iter.next();
Expression initializer = fragment.getInitializer();
if (initializer != null) {
Assignment assignment = ast.newAssignment();
assignment.setLeftHandSide(
(Expression) fRewriter.createCopyTarget(fragment.getName()));
assignment.setRightHandSide((Expression) fRewriter.createCopyTarget(initializer));
newExpressionStatements.add(ast.newExpressionStatement(assignment));
}
}
if (!newExpressionStatements.isEmpty()) {
if (fSelectedNodes.length == 1) {
expressionStatement =
fRewriter.createGroupNode(
newExpressionStatements.toArray(new ASTNode[newExpressionStatements.size()]));
} else {
fRewriter.replace(
statement,
fRewriter.createGroupNode(
newExpressionStatements.toArray(new ASTNode[newExpressionStatements.size()])),
null);
}
} else {
fRewriter.remove(statement, null);
selectedNodeRemoved = true;
}
} else {
fRewriter.remove(statement, null);
selectedNodeRemoved = true;
}
}
}
result.add(tryStatement);
ASTNode replacementNode;
if (result.size() == 1) {
replacementNode = result.get(0);
} else {
replacementNode = fRewriter.createGroupNode(result.toArray(new ASTNode[result.size()]));
}
if (fSelectedNodes.length == 1) {
ASTNode selectedNode = fSelectedNodes[0];
if (selectedNode instanceof MethodReference) {
MethodReference methodReference = (MethodReference) selectedNode;
IMethodBinding functionalMethod =
QuickAssistProcessor.getFunctionalMethodForMethodReference(methodReference);
// functionalMethod is non-null and non-generic. See
// ExceptionAnalyzer.handleMethodReference(MethodReference node).
Assert.isTrue(functionalMethod != null && !functionalMethod.isGenericMethod());
LambdaExpression lambda =
QuickAssistProcessor.convertMethodRefernceToLambda(
methodReference, functionalMethod, fRootNode, fRewriter, null, true);
ASTNode statementInBlock = (ASTNode) ((Block) lambda.getBody()).statements().get(0);
fRewriter.replace(statementInBlock, replacementNode, null);
statements.insertLast(statementInBlock, null);
return;
}
LambdaExpression enclosingLambda = ASTResolving.findEnclosingLambdaExpression(selectedNode);
if (enclosingLambda != null
&& selectedNode.getLocationInParent() == LambdaExpression.BODY_PROPERTY
&& enclosingLambda.resolveMethodBinding() != null) {
QuickAssistProcessor.changeLambdaBodyToBlock(enclosingLambda, getAST(), fRewriter);
Block blockBody = (Block) fRewriter.get(enclosingLambda, LambdaExpression.BODY_PROPERTY);
ASTNode statementInBlock = (ASTNode) blockBody.statements().get(0);
fRewriter.replace(statementInBlock, replacementNode, null);
statements.insertLast(statementInBlock, null);
return;
}
if (expressionStatement != null) {
statements.insertLast(expressionStatement, null);
} else {
if (!selectedNodeRemoved)
statements.insertLast(fRewriter.createMoveTarget(selectedNode), null);
}
fRewriter.replace(selectedNode, replacementNode, null);
} else {
ListRewrite source =
fRewriter.getListRewrite(
fSelectedNodes[0].getParent(),
(ChildListPropertyDescriptor) fSelectedNodes[0].getLocationInParent());
ASTNode toMove =
source.createMoveTarget(
fSelectedNodes[0], fSelectedNodes[fSelectedNodes.length - 1], replacementNode, null);
statements.insertLast(toMove, null);
}
}