Examples with ASTRewriteRemoveImportsCorrectionProposal org.eclipse.jdt.ls.core.internal.corrections.proposals.ASTRewriteRemoveImportsCorrectionProposal used on opensource projects

Example 1 with ASTRewriteRemoveImportsCorrectionProposal

use of org.eclipse.jdt.ls.core.internal.corrections.proposals.ASTRewriteRemoveImportsCorrectionProposal in project eclipse.jdt.ls by eclipse.

the class RefactorProcessor method getAddStaticImportProposals.

/**
 * Create static import proposal, which converts invocations to static import.
 *
 * @param context
 *            the invocation context
 * @param node
 *            the node to work on
 * @param proposals
 *            the receiver of proposals, may be {@code null}
 * @return {@code true} if the operation could or has been performed,
 *         {@code false otherwise}
 */
private static boolean getAddStaticImportProposals(IInvocationContext context, ASTNode node, Collection<ChangeCorrectionProposal> proposals) {
    if (!(node instanceof SimpleName)) {
        return false;
    }
    final SimpleName name = (SimpleName) node;
    final IBinding binding;
    final ITypeBinding declaringClass;
    if (name.getParent() instanceof MethodInvocation) {
        MethodInvocation mi = (MethodInvocation) name.getParent();
        Expression expression = mi.getExpression();
        if (expression == null || expression.equals(name)) {
            return false;
        }
        binding = mi.resolveMethodBinding();
        if (binding == null) {
            return false;
        }
        declaringClass = ((IMethodBinding) binding).getDeclaringClass();
    } else if (name.getParent() instanceof QualifiedName) {
        QualifiedName qn = (QualifiedName) name.getParent();
        if (name.equals(qn.getQualifier()) || qn.getParent() instanceof ImportDeclaration) {
            return false;
        }
        binding = qn.resolveBinding();
        if (!(binding instanceof IVariableBinding)) {
            return false;
        }
        declaringClass = ((IVariableBinding) binding).getDeclaringClass();
    } else {
        return false;
    }
    if (!Modifier.isStatic(binding.getModifiers())) {
        // only work with static bindings
        return false;
    }
    boolean needImport = false;
    if (!isDirectlyAccessible(name, declaringClass)) {
        if (Modifier.isPrivate(declaringClass.getModifiers())) {
            return false;
        }
        needImport = true;
    }
    if (proposals == null) {
        // return early, just testing if we could do it
        return true;
    }
    try {
        ImportRewrite importRewrite = StubUtility.createImportRewrite(context.getCompilationUnit(), true);
        ASTRewrite astRewrite = ASTRewrite.create(node.getAST());
        ASTRewrite astRewriteReplaceAllOccurrences = ASTRewrite.create(node.getAST());
        ImportRemover remover = new ImportRemover(context.getCompilationUnit().getJavaProject(), context.getASTRoot());
        ImportRemover removerAllOccurences = new ImportRemover(context.getCompilationUnit().getJavaProject(), context.getASTRoot());
        MethodInvocation mi = null;
        QualifiedName qn = null;
        if (name.getParent() instanceof MethodInvocation) {
            mi = (MethodInvocation) name.getParent();
            // convert the method invocation
            astRewrite.remove(mi.getExpression(), null);
            remover.registerRemovedNode(mi.getExpression());
            removerAllOccurences.registerRemovedNode(mi.getExpression());
            mi.typeArguments().forEach(typeObject -> {
                Type type = (Type) typeObject;
                astRewrite.remove(type, null);
                remover.registerRemovedNode(type);
                removerAllOccurences.registerRemovedNode(type);
            });
        } else if (name.getParent() instanceof QualifiedName) {
            qn = (QualifiedName) name.getParent();
            // convert the field access
            astRewrite.replace(qn, ASTNodeFactory.newName(node.getAST(), name.getFullyQualifiedName()), null);
            remover.registerRemovedNode(qn);
            removerAllOccurences.registerRemovedNode(qn);
        } else {
            return false;
        }
        MethodInvocation miFinal = mi;
        name.getRoot().accept(new ASTVisitor() {

            @Override
            public boolean visit(MethodInvocation methodInvocation) {
                Expression methodInvocationExpression = methodInvocation.getExpression();
                if (methodInvocationExpression == null) {
                    return super.visit(methodInvocation);
                }
                if (methodInvocationExpression instanceof Name) {
                    String fullyQualifiedName = ((Name) methodInvocationExpression).getFullyQualifiedName();
                    if (miFinal != null && miFinal.getExpression() instanceof Name && ((Name) miFinal.getExpression()).getFullyQualifiedName().equals(fullyQualifiedName) && miFinal.getName().getIdentifier().equals(methodInvocation.getName().getIdentifier())) {
                        methodInvocation.typeArguments().forEach(type -> {
                            astRewriteReplaceAllOccurrences.remove((Type) type, null);
                            removerAllOccurences.registerRemovedNode((Type) type);
                        });
                        astRewriteReplaceAllOccurrences.remove(methodInvocationExpression, null);
                        removerAllOccurences.registerRemovedNode(methodInvocationExpression);
                    }
                }
                return super.visit(methodInvocation);
            }
        });
        QualifiedName qnFinal = qn;
        name.getRoot().accept(new ASTVisitor() {

            @Override
            public boolean visit(QualifiedName qualifiedName) {
                if (qnFinal != null && qualifiedName.getFullyQualifiedName().equals(qnFinal.getFullyQualifiedName())) {
                    astRewriteReplaceAllOccurrences.replace(qualifiedName, ASTNodeFactory.newName(node.getAST(), name.getFullyQualifiedName()), null);
                    removerAllOccurences.registerRemovedNode(qualifiedName);
                }
                return super.visit(qualifiedName);
            }
        });
        if (needImport) {
            importRewrite.addStaticImport(binding);
        }
        ASTRewriteRemoveImportsCorrectionProposal proposal = new ASTRewriteRemoveImportsCorrectionProposal(CorrectionMessages.QuickAssistProcessor_convert_to_static_import, CodeActionKind.Refactor, context.getCompilationUnit(), astRewrite, IProposalRelevance.ADD_STATIC_IMPORT);
        proposal.setImportRewrite(importRewrite);
        proposal.setImportRemover(remover);
        proposals.add(proposal);
        ASTRewriteRemoveImportsCorrectionProposal proposalReplaceAllOccurrences = new ASTRewriteRemoveImportsCorrectionProposal(CorrectionMessages.QuickAssistProcessor_convert_to_static_import_replace_all, CodeActionKind.Refactor, context.getCompilationUnit(), astRewriteReplaceAllOccurrences, IProposalRelevance.ADD_STATIC_IMPORT);
        proposalReplaceAllOccurrences.setImportRewrite(importRewrite);
        proposalReplaceAllOccurrences.setImportRemover(removerAllOccurences);
        proposals.add(proposalReplaceAllOccurrences);
    } catch (IllegalArgumentException e) {
        // Wrong use of ASTRewrite or ImportRewrite API, see bug 541586
        JavaLanguageServerPlugin.logException("Failed to get static import proposal", e);
        return false;
    } catch (JavaModelException e) {
        return false;
    }
    return true;
}