Examples with ImportDeclaration org.eclipse.jdt.core.dom.ImportDeclaration used on opensource projects

Example 21 with ImportDeclaration

use of org.eclipse.jdt.core.dom.ImportDeclaration in project AutoRefactor by JnRouvignac.

the class JUnitAssertCleanUp method visit.

@Override
public boolean visit(final CompilationUnit visited) {
    canUseAssertNotEquals = false;
    for (Object object : visited.imports()) {
        ImportDeclaration importDeclaration = (ImportDeclaration) object;
        ITypeBinding typeBinding = resolveTypeBinding(importDeclaration);
        if (ASTNodes.hasType(typeBinding, "org.junit.Assert")) {
            // $NON-NLS-1$
            for (IMethodBinding mb : typeBinding.getDeclaredMethods()) {
                if (mb.toString().contains("assertNotEquals")) {
                    // $NON-NLS-1$
                    canUseAssertNotEquals = true;
                    return super.visit(visited);
                }
            }
        }
    }
    // New file: reset the value
    return super.visit(visited);
}

Example 22 with ImportDeclaration

use of org.eclipse.jdt.core.dom.ImportDeclaration in project AutoRefactor by JnRouvignac.

the class NewClassImportCleanUp method getAlreadyImportedClasses.

/**
 * True if an import already exists for a class.
 *
 * @param node One node in the class file
 * @return True if an import already exists for a class.
 */
public Set<String> getAlreadyImportedClasses(final ASTNode node) {
    Set<String> alreadyImportedClasses = new HashSet<>();
    CompilationUnit cu = (CompilationUnit) node.getRoot();
    Set<String> classesToUse = getClassesToImport();
    Map<String, String> importsByPackage = new HashMap<>();
    for (String klass : classesToUse) {
        importsByPackage.put(getPackageName(klass), klass);
    }
    for (Object anObject : cu.imports()) {
        ImportDeclaration anImport = (ImportDeclaration) anObject;
        if (anImport.isOnDemand()) {
            String fullName = importsByPackage.get(anImport.getName().getFullyQualifiedName());
            if (fullName != null) {
                alreadyImportedClasses.add(fullName);
            }
        } else if (classesToUse.contains(anImport.getName().getFullyQualifiedName())) {
            alreadyImportedClasses.add(anImport.getName().getFullyQualifiedName());
        }
    }
    return alreadyImportedClasses;
}

Example 23 with ImportDeclaration

use of org.eclipse.jdt.core.dom.ImportDeclaration in project AutoRefactor by JnRouvignac.

the class NewClassImportCleanUp method visit.

@Override
public boolean visit(final CompilationUnit node) {
    if (!super.visit(node)) {
        return false;
    }
    Set<String> classesToUse = getClassesToImport();
    if (classesToUse.isEmpty()) {
        return true;
    }
    Map<String, String> importsByClassname = new HashMap<>();
    Map<String, String> importsByPackage = new HashMap<>();
    for (String klass : classesToUse) {
        importsByClassname.put(getSimpleName(klass), klass);
        importsByPackage.put(getPackageName(klass), klass);
    }
    Set<String> alreadyImportedClasses = new HashSet<>();
    Set<String> classesToImport = new HashSet<>(classesToUse);
    for (Object anObject : node.imports()) {
        ImportDeclaration anImport = (ImportDeclaration) anObject;
        if (!anImport.isStatic()) {
            if (anImport.isOnDemand()) {
                String fullName = importsByPackage.get(anImport.getName().getFullyQualifiedName());
                if (fullName != null) {
                    alreadyImportedClasses.add(fullName);
                }
            } else if (classesToUse.contains(anImport.getName().getFullyQualifiedName())) {
                alreadyImportedClasses.add(anImport.getName().getFullyQualifiedName());
                classesToImport.remove(anImport.getName().getFullyQualifiedName());
            } else if (importsByClassname.containsKey(getSimpleName(anImport.getName().getFullyQualifiedName()))) {
                classesToImport.remove(importsByClassname.get(getSimpleName(anImport.getName().getFullyQualifiedName())));
            }
        }
    }
    filterLocallyUsedNames(node, importsByClassname, classesToImport);
    if (alreadyImportedClasses.size() < classesToUse.size() && !classesToImport.isEmpty()) {
        CleanUpWithNewClassImport refactoringClass = getRefactoringClassInstance();
        refactoringClass.getClassesToUseWithImport().addAll(alreadyImportedClasses);
        refactoringClass.getClassesToUseWithImport().addAll(classesToImport);
        node.accept(refactoringClass);
        if (!refactoringClass.getImportsToAdd().isEmpty()) {
            ASTRewrite rewrite = cuRewrite.getASTRewrite();
            for (String importToAdd : refactoringClass.getImportsToAdd()) {
                rewrite.getImportRewrite().addImport(importToAdd);
            }
            return false;
        }
    }
    return true;
}

Example 24 with ImportDeclaration

use of org.eclipse.jdt.core.dom.ImportDeclaration in project eclipse.jdt.ls by eclipse.

the class TypeContextChecker method createStubTypeContext.

public static StubTypeContext createStubTypeContext(ICompilationUnit cu, CompilationUnit root, int focalPosition) throws CoreException {
    StringBuilder bufBefore = new StringBuilder();
    StringBuilder bufAfter = new StringBuilder();
    int introEnd = 0;
    PackageDeclaration pack = root.getPackage();
    if (pack != null) {
        introEnd = pack.getStartPosition() + pack.getLength();
    }
    List<ImportDeclaration> imports = root.imports();
    if (imports.size() > 0) {
        ImportDeclaration lastImport = imports.get(imports.size() - 1);
        introEnd = lastImport.getStartPosition() + lastImport.getLength();
    }
    bufBefore.append(cu.getBuffer().getText(0, introEnd));
    fillWithTypeStubs(bufBefore, bufAfter, focalPosition, root.types());
    bufBefore.append(' ');
    bufAfter.insert(0, ' ');
    return new StubTypeContext(cu, bufBefore.toString(), bufAfter.toString());
}

Example 25 with ImportDeclaration

use of org.eclipse.jdt.core.dom.ImportDeclaration 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;
}