Example usage for org.eclipse.jdt.core.compiler IProblem UnusedImport

List of usage examples for org.eclipse.jdt.core.compiler IProblem UnusedImport

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.compiler.*
  5. IProblem
  6. UnusedImport

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.compiler IProblem UnusedImport.

Prototype

int UnusedImport

To view the source code for org.eclipse.jdt.core.compiler IProblem UnusedImport.

Click Source Link

Usage

From source file:com.google.gdt.eclipse.appengine.rpc.util.CompilationUnitCreator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void removeUnusedImports(ICompilationUnit cu, Set<String> existingImports, boolean needsSave)
        throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(cu);//from   w  w w .j  a va  2  s  .co  m
    parser.setResolveBindings(true);

    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    if (root.getProblems().length == 0) {
        return;
    }

    List<ImportDeclaration> importsDecls = root.imports();
    if (importsDecls.isEmpty()) {
        return;
    }
    ImportsManager imports = new ImportsManager(root);

    int importsEnd = ASTNodes.getExclusiveEnd((ASTNode) importsDecls.get(importsDecls.size() - 1));
    IProblem[] problems = root.getProblems();
    for (int i = 0; i < problems.length; i++) {
        IProblem curr = problems[i];
        if (curr.getSourceEnd() < importsEnd) {
            int id = curr.getID();
            if (id == IProblem.UnusedImport || id == IProblem.NotVisibleType) {
                int pos = curr.getSourceStart();
                for (int k = 0; k < importsDecls.size(); k++) {
                    ImportDeclaration decl = importsDecls.get(k);
                    if (decl.getStartPosition() <= pos && pos < decl.getStartPosition() + decl.getLength()) {
                        if (existingImports.isEmpty() || !existingImports.contains(ASTNodes.asString(decl))) {
                            String name = decl.getName().getFullyQualifiedName();
                            if (decl.isOnDemand()) {
                                name += ".*"; //$NON-NLS-1$
                            }
                            if (decl.isStatic()) {
                                imports.removeStaticImport(name);
                            } else {
                                imports.removeImport(name);
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    imports.create(needsSave, null);
}

From source file:com.google.gdt.eclipse.appengine.rpc.wizards.helpers.RpcServiceLayerCreator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void removeUnusedImports(ICompilationUnit cu, Set<String> existingImports, boolean needsSave)
        throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(cu);//from  www .  j  a  va  2 s  .com
    parser.setResolveBindings(true);

    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    if (root.getProblems().length == 0) {
        return;
    }

    List<ImportDeclaration> importsDecls = root.imports();
    if (importsDecls.isEmpty()) {
        return;
    }
    ImportsManager imports = new ImportsManager(root);

    int importsEnd = ASTNodes.getExclusiveEnd(importsDecls.get(importsDecls.size() - 1));
    IProblem[] problems = root.getProblems();
    for (int i = 0; i < problems.length; i++) {
        IProblem curr = problems[i];
        if (curr.getSourceEnd() < importsEnd) {
            int id = curr.getID();
            if (id == IProblem.UnusedImport || id == IProblem.NotVisibleType) {
                int pos = curr.getSourceStart();
                for (int k = 0; k < importsDecls.size(); k++) {
                    ImportDeclaration decl = importsDecls.get(k);
                    if (decl.getStartPosition() <= pos && pos < decl.getStartPosition() + decl.getLength()) {
                        if (existingImports.isEmpty() || !existingImports.contains(ASTNodes.asString(decl))) {
                            String name = decl.getName().getFullyQualifiedName();
                            if (decl.isOnDemand()) {
                                name += ".*"; //$NON-NLS-1$
                            }
                            if (decl.isStatic()) {
                                imports.removeStaticImport(name);
                            } else {
                                imports.removeImport(name);
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    imports.create(needsSave, null);
}

From source file:com.iw.plugins.spindle.ui.wizards.factories.ClassFactory.java

License:Mozilla Public License

private void removeUnusedImports(ICompilationUnit cu, Set addedTypes, boolean needsSave) throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS2);
    parser.setSource(cu);/*from   w w  w .  j  a  va 2 s .  co m*/
    parser.setResolveBindings(true);
    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    IProblem[] problems = root.getProblems();
    ArrayList res = new ArrayList();
    for (int i = 0; i < problems.length; i++) {
        int id = problems[i].getID();
        if (id == IProblem.UnusedImport || id == IProblem.ImportNotVisible) { // not visibles hide unused -> remove both
            String imp = problems[i].getArguments()[0];
            res.add(imp);
        }
    }
    if (!res.isEmpty()) {
        ImportsManager imports = new ImportsManager(cu, addedTypes);
        for (int i = 0; i < res.size(); i++) {
            String curr = (String) res.get(i);
            imports.removeImport(curr);
        }
        imports.create(needsSave, null);
    }
}

From source file:org.eclipse.ajdt.internal.ui.editor.quickfix.QuickFixProcessor.java

License:Open Source License

public boolean hasCorrections(ICompilationUnit cu, int problemId) {
    switch (problemId) {
    case IProblem.UnterminatedString:
    case IProblem.UnusedImport:
    case IProblem.DuplicateImport:
    case IProblem.CannotImportPackage:
    case IProblem.ConflictingImport:
    case IProblem.ImportNotFound:
    case IProblem.UndefinedMethod:
    case IProblem.UndefinedConstructor:
    case IProblem.ParameterMismatch:
    case IProblem.MethodButWithConstructorName:
    case IProblem.UndefinedField:
    case IProblem.UndefinedName:
    case IProblem.PublicClassMustMatchFileName:
    case IProblem.PackageIsNotExpectedPackage:
    case IProblem.UndefinedType:
    case IProblem.TypeMismatch:
    case IProblem.UnhandledException:
    case IProblem.UnreachableCatch:
    case IProblem.InvalidCatchBlockSequence:
    case IProblem.VoidMethodReturnsValue:
    case IProblem.ShouldReturnValue:
    case IProblem.MissingReturnType:
    case IProblem.NonExternalizedStringLiteral:
    case IProblem.NonStaticAccessToStaticField:
    case IProblem.NonStaticAccessToStaticMethod:
    case IProblem.StaticMethodRequested:
    case IProblem.NonStaticFieldFromStaticInvocation:
    case IProblem.InstanceMethodDuringConstructorInvocation:
    case IProblem.InstanceFieldDuringConstructorInvocation:
    case IProblem.NotVisibleMethod:
    case IProblem.NotVisibleConstructor:
    case IProblem.NotVisibleType:
    case IProblem.NotVisibleField:
    case IProblem.BodyForAbstractMethod:
    case IProblem.AbstractMethodInAbstractClass:
    case IProblem.AbstractMethodMustBeImplemented:
    case IProblem.BodyForNativeMethod:
    case IProblem.OuterLocalMustBeFinal:
    case IProblem.UninitializedLocalVariable:
    case IProblem.UndefinedConstructorInDefaultConstructor:
    case IProblem.UnhandledExceptionInDefaultConstructor:
    case IProblem.NotVisibleConstructorInDefaultConstructor:
    case IProblem.AmbiguousType:
    case IProblem.UnusedPrivateMethod:
    case IProblem.UnusedPrivateConstructor:
    case IProblem.UnusedPrivateField:
    case IProblem.UnusedPrivateType:
    case IProblem.LocalVariableIsNeverUsed:
    case IProblem.ArgumentIsNeverUsed:
    case IProblem.MethodRequiresBody:
    case IProblem.NeedToEmulateFieldReadAccess:
    case IProblem.NeedToEmulateFieldWriteAccess:
    case IProblem.NeedToEmulateMethodAccess:
    case IProblem.NeedToEmulateConstructorAccess:
    case IProblem.SuperfluousSemicolon:
    case IProblem.UnnecessaryCast:
    case IProblem.UnnecessaryInstanceof:
    case IProblem.IndirectAccessToStaticField:
    case IProblem.IndirectAccessToStaticMethod:
    case IProblem.Task:
    case IProblem.UnusedMethodDeclaredThrownException:
    case IProblem.UnusedConstructorDeclaredThrownException:
    case IProblem.UnqualifiedFieldAccess:
    case IProblem.JavadocMissing:
    case IProblem.JavadocMissingParamTag:
    case IProblem.JavadocMissingReturnTag:
    case IProblem.JavadocMissingThrowsTag:
    case IProblem.JavadocUndefinedType:
    case IProblem.JavadocAmbiguousType:
    case IProblem.JavadocNotVisibleType:
    case IProblem.JavadocInvalidThrowsClassName:
    case IProblem.JavadocDuplicateThrowsClassName:
    case IProblem.JavadocDuplicateReturnTag:
    case IProblem.JavadocDuplicateParamName:
    case IProblem.JavadocInvalidParamName:
    case IProblem.JavadocUnexpectedTag:
    case IProblem.JavadocInvalidTag:
    case IProblem.NonBlankFinalLocalAssignment:
    case IProblem.DuplicateFinalLocalInitialization:
    case IProblem.FinalFieldAssignment:
    case IProblem.DuplicateBlankFinalFieldInitialization:
    case IProblem.AnonymousClassCannotExtendFinalClass:
    case IProblem.ClassExtendFinalClass:
    case IProblem.FinalMethodCannotBeOverridden:
    case IProblem.InheritedMethodReducesVisibility:
    case IProblem.MethodReducesVisibility:
    case IProblem.OverridingNonVisibleMethod:
    case IProblem.CannotOverrideAStaticMethodWithAnInstanceMethod:
    case IProblem.CannotHideAnInstanceMethodWithAStaticMethod:
    case IProblem.UnexpectedStaticModifierForMethod:
    case IProblem.LocalVariableHidingLocalVariable:
    case IProblem.LocalVariableHidingField:
    case IProblem.FieldHidingLocalVariable:
    case IProblem.FieldHidingField:
    case IProblem.ArgumentHidingLocalVariable:
    case IProblem.ArgumentHidingField:
    case IProblem.IllegalModifierForInterfaceMethod:
    case IProblem.IllegalModifierForInterface:
    case IProblem.IllegalModifierForClass:
    case IProblem.IllegalModifierForInterfaceField:
    case IProblem.IllegalModifierForMemberInterface:
    case IProblem.IllegalModifierForMemberClass:
    case IProblem.IllegalModifierForLocalClass:
    case IProblem.IllegalModifierForArgument:
    case IProblem.IllegalModifierForField:
    case IProblem.IllegalModifierForMethod:
    case IProblem.IllegalModifierForVariable:
    case IProblem.IllegalVisibilityModifierForInterfaceMemberType:
    case IProblem.IncompatibleReturnType:
    case IProblem.IncompatibleExceptionInThrowsClause:
    case IProblem.NoMessageSendOnArrayType:
    case IProblem.InvalidOperator:
    case IProblem.MissingSerialVersion:
    case IProblem.UnnecessaryElse:
    case IProblem.SuperclassMustBeAClass:
    case IProblem.UseAssertAsAnIdentifier:
    case IProblem.UseEnumAsAnIdentifier:
    case IProblem.RedefinedLocal:
    case IProblem.RedefinedArgument:
    case IProblem.CodeCannotBeReached:
    case IProblem.InvalidUsageOfTypeParameters:
    case IProblem.InvalidUsageOfStaticImports:
    case IProblem.InvalidUsageOfForeachStatements:
    case IProblem.InvalidUsageOfTypeArguments:
    case IProblem.InvalidUsageOfEnumDeclarations:
    case IProblem.InvalidUsageOfVarargs:
    case IProblem.InvalidUsageOfAnnotations:
    case IProblem.InvalidUsageOfAnnotationDeclarations:
    case IProblem.FieldMissingDeprecatedAnnotation:
    case IProblem.MethodMissingDeprecatedAnnotation:
    case IProblem.TypeMissingDeprecatedAnnotation:
    case IProblem.MissingOverrideAnnotation:
    case IProblem.IsClassPathCorrect:
    case IProblem.MethodReturnsVoid:
    case IProblem.ForbiddenReference:
    case IProblem.DiscouragedReference:
    case IProblem.UnnecessaryNLSTag:
    case IProblem.AssignmentHasNoEffect:
    case IProblem.UnsafeTypeConversion:
    case IProblem.UndefinedAnnotationMember:
    case IProblem.MissingValueForAnnotationMember:
    case IProblem.FallthroughCase:
    case IProblem.NonGenericType:
    case IProblem.UnhandledWarningToken:
        return true;
    default:/*from   w w w.  j av a 2  s  .  c o m*/
        if (JavaModelUtil.is50OrHigher(cu.getJavaProject())) {
            return SuppressWarningsSubProcessor.hasSuppressWarningsProposal(cu.getJavaProject(), problemId); // AJDT 3.6
        }
        return false;
    }
}

From source file:org.eclipse.ajdt.internal.ui.editor.quickfix.QuickFixProcessor.java

License:Open Source License

private void process(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals)
        throws CoreException {
    int id = problem.getProblemId();
    if (id == 0) { // no proposals for none-problem locations
        return;//  w ww . j a v a2 s  .  c o  m
    }
    switch (id) {
    case IProblem.UnterminatedString:
        String quoteLabel = CorrectionMessages.JavaCorrectionProcessor_addquote_description;
        int pos = moveBack(problem.getOffset() + problem.getLength(), problem.getOffset(), "\n\r", //$NON-NLS-1$
                context.getCompilationUnit());
        proposals.add(new ReplaceCorrectionProposal(quoteLabel, context.getCompilationUnit(), pos, 0, "\"", 0)); //$NON-NLS-1$
        break;
    case IProblem.UnusedImport:
    case IProblem.DuplicateImport:
    case IProblem.CannotImportPackage:
    case IProblem.ConflictingImport:
        ReorgCorrectionsSubProcessor.removeImportStatementProposals(context, problem, proposals);
        break;
    case IProblem.ImportNotFound:
        ReorgCorrectionsSubProcessor.importNotFoundProposals(context, problem, proposals);
        ReorgCorrectionsSubProcessor.removeImportStatementProposals(context, problem, proposals);
        break;
    case IProblem.UndefinedMethod:
        UnresolvedElementsSubProcessor.getMethodProposals(context, problem, false, proposals);
        break;
    case IProblem.UndefinedConstructor:
        UnresolvedElementsSubProcessor.getConstructorProposals(context, problem, proposals);
        break;
    case IProblem.UndefinedAnnotationMember:
        UnresolvedElementsSubProcessor.getAnnotationMemberProposals(context, problem, proposals);
        break;
    case IProblem.ParameterMismatch:
        UnresolvedElementsSubProcessor.getMethodProposals(context, problem, true, proposals);
        break;
    case IProblem.MethodButWithConstructorName:
        ReturnTypeSubProcessor.addMethodWithConstrNameProposals(context, problem, proposals);
        break;
    case IProblem.UndefinedField:
    case IProblem.UndefinedName:
        UnresolvedElementsSubProcessor.getVariableProposals(context, problem, null, proposals);
        break;
    case IProblem.AmbiguousType:
    case IProblem.JavadocAmbiguousType:
        UnresolvedElementsSubProcessor.getAmbiguosTypeReferenceProposals(context, problem, proposals);
        break;
    case IProblem.PublicClassMustMatchFileName:
        ReorgCorrectionsSubProcessor.getWrongTypeNameProposals(context, problem, proposals);
        break;
    case IProblem.PackageIsNotExpectedPackage:
        ReorgCorrectionsSubProcessor.getWrongPackageDeclNameProposals(context, problem, proposals);
        break;
    case IProblem.UndefinedType:
    case IProblem.JavadocUndefinedType:
        UnresolvedElementsSubProcessor.getTypeProposals(context, problem, proposals);
        break;
    case IProblem.TypeMismatch:
        // AspectJ Change
        if (problem.getProblemArguments() != null) { // Bug 265052
            TypeMismatchSubProcessor.addTypeMismatchProposals(context, problem, proposals);
        }
        break;
    case IProblem.IncompatibleReturnType:
        TypeMismatchSubProcessor.addIncompatibleReturnTypeProposals(context, problem, proposals);
        break;
    case IProblem.IncompatibleExceptionInThrowsClause:
        TypeMismatchSubProcessor.addIncompatibleThrowsProposals(context, problem, proposals);
        break;
    case IProblem.UnhandledException:
        LocalCorrectionsSubProcessor.addUncaughtExceptionProposals(context, problem, proposals);
        break;
    case IProblem.UnreachableCatch:
    case IProblem.InvalidCatchBlockSequence:
        LocalCorrectionsSubProcessor.addUnreachableCatchProposals(context, problem, proposals);
        break;
    case IProblem.VoidMethodReturnsValue:
        ReturnTypeSubProcessor.addVoidMethodReturnsProposals(context, problem, proposals);
        break;
    case IProblem.MethodReturnsVoid:
        ReturnTypeSubProcessor.addMethodRetunsVoidProposals(context, problem, proposals);
        break;
    case IProblem.MissingReturnType:
        ReturnTypeSubProcessor.addMissingReturnTypeProposals(context, problem, proposals);
        break;
    case IProblem.ShouldReturnValue:
        ReturnTypeSubProcessor.addMissingReturnStatementProposals(context, problem, proposals);
        break;
    case IProblem.NonExternalizedStringLiteral:
        LocalCorrectionsSubProcessor.addNLSProposals(context, problem, proposals);
        break;
    case IProblem.UnnecessaryNLSTag:
        LocalCorrectionsSubProcessor.getUnnecessaryNLSTagProposals(context, problem, proposals);
        break;
    case IProblem.NonStaticAccessToStaticField:
    case IProblem.NonStaticAccessToStaticMethod:
    case IProblem.IndirectAccessToStaticField:
    case IProblem.IndirectAccessToStaticMethod:
        LocalCorrectionsSubProcessor.addCorrectAccessToStaticProposals(context, problem, proposals);
        break;
    case IProblem.StaticMethodRequested:
    case IProblem.NonStaticFieldFromStaticInvocation:
    case IProblem.InstanceMethodDuringConstructorInvocation:
    case IProblem.InstanceFieldDuringConstructorInvocation:
        ModifierCorrectionSubProcessor.addNonAccessibleReferenceProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_STATIC, 5);
        break;
    case IProblem.NonBlankFinalLocalAssignment:
    case IProblem.DuplicateFinalLocalInitialization:
    case IProblem.FinalFieldAssignment:
    case IProblem.DuplicateBlankFinalFieldInitialization:
    case IProblem.AnonymousClassCannotExtendFinalClass:
    case IProblem.ClassExtendFinalClass:
        ModifierCorrectionSubProcessor.addNonAccessibleReferenceProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_NON_FINAL, 9);
        break;
    case IProblem.InheritedMethodReducesVisibility:
    case IProblem.MethodReducesVisibility:
    case IProblem.OverridingNonVisibleMethod:
        ModifierCorrectionSubProcessor.addChangeOverriddenModifierProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_VISIBLE);
        break;
    case IProblem.FinalMethodCannotBeOverridden:
        ModifierCorrectionSubProcessor.addChangeOverriddenModifierProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_NON_FINAL);
        break;
    case IProblem.CannotOverrideAStaticMethodWithAnInstanceMethod:
        ModifierCorrectionSubProcessor.addChangeOverriddenModifierProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_NON_STATIC);
        break;
    case IProblem.CannotHideAnInstanceMethodWithAStaticMethod:
    case IProblem.IllegalModifierForInterfaceMethod:
    case IProblem.IllegalModifierForInterface:
    case IProblem.IllegalModifierForClass:
    case IProblem.IllegalModifierForInterfaceField:
    case IProblem.IllegalModifierForMemberInterface:
    case IProblem.IllegalModifierForMemberClass:
    case IProblem.IllegalModifierForLocalClass:
    case IProblem.IllegalModifierForArgument:
    case IProblem.IllegalModifierForField:
    case IProblem.IllegalModifierForMethod:
    case IProblem.IllegalModifierForVariable:
    case IProblem.IllegalVisibilityModifierForInterfaceMemberType:
    case IProblem.UnexpectedStaticModifierForMethod:
        ModifierCorrectionSubProcessor.addRemoveInvalidModifiersProposal(context, problem, proposals, 5);
        break;
    case IProblem.NotVisibleMethod:
    case IProblem.NotVisibleConstructor:
    case IProblem.NotVisibleType:
    case IProblem.NotVisibleField:
    case IProblem.JavadocNotVisibleType:
        ModifierCorrectionSubProcessor.addNonAccessibleReferenceProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_VISIBLE, 10);
        break;
    case IProblem.BodyForAbstractMethod:
    case IProblem.AbstractMethodInAbstractClass:
        ModifierCorrectionSubProcessor.addAbstractMethodProposals(context, problem, proposals);
        break;
    case IProblem.AbstractMethodMustBeImplemented:
        LocalCorrectionsSubProcessor.addUnimplementedMethodsProposals(context, problem, proposals);
        break;
    case IProblem.MissingValueForAnnotationMember:
        LocalCorrectionsSubProcessor.addValueForAnnotationProposals(context, problem, proposals);
        break;
    case IProblem.BodyForNativeMethod:
        ModifierCorrectionSubProcessor.addNativeMethodProposals(context, problem, proposals);
        break;
    case IProblem.MethodRequiresBody:
        ModifierCorrectionSubProcessor.addMethodRequiresBodyProposals(context, problem, proposals);
        break;
    case IProblem.OuterLocalMustBeFinal:
        ModifierCorrectionSubProcessor.addNonFinalLocalProposal(context, problem, proposals);
        break;
    case IProblem.UninitializedLocalVariable:
        LocalCorrectionsSubProcessor.addUninitializedLocalVariableProposal(context, problem, proposals);
        break;
    case IProblem.UnhandledExceptionInDefaultConstructor:
    case IProblem.UndefinedConstructorInDefaultConstructor:
    case IProblem.NotVisibleConstructorInDefaultConstructor:
        LocalCorrectionsSubProcessor.addConstructorFromSuperclassProposal(context, problem, proposals);
        break;
    case IProblem.UnusedPrivateMethod:
    case IProblem.UnusedPrivateConstructor:
    case IProblem.UnusedPrivateField:
    case IProblem.UnusedPrivateType:
    case IProblem.LocalVariableIsNeverUsed:
    case IProblem.ArgumentIsNeverUsed:
        LocalCorrectionsSubProcessor.addUnusedMemberProposal(context, problem, proposals);
        break;
    case IProblem.NeedToEmulateFieldReadAccess:
    case IProblem.NeedToEmulateFieldWriteAccess:
    case IProblem.NeedToEmulateMethodAccess:
    case IProblem.NeedToEmulateConstructorAccess:
        ModifierCorrectionSubProcessor.addNonAccessibleReferenceProposal(context, problem, proposals,
                ModifierCorrectionSubProcessor.TO_NON_PRIVATE, 5);
        break;
    case IProblem.SuperfluousSemicolon:
        LocalCorrectionsSubProcessor.addSuperfluousSemicolonProposal(context, problem, proposals);
        break;
    case IProblem.UnnecessaryCast:
        LocalCorrectionsSubProcessor.addUnnecessaryCastProposal(context, problem, proposals);
        break;
    case IProblem.UnnecessaryInstanceof:
        LocalCorrectionsSubProcessor.addUnnecessaryInstanceofProposal(context, problem, proposals);
        break;
    case IProblem.UnusedMethodDeclaredThrownException:
    case IProblem.UnusedConstructorDeclaredThrownException:
        LocalCorrectionsSubProcessor.addUnnecessaryThrownExceptionProposal(context, problem, proposals);
        break;
    case IProblem.UnqualifiedFieldAccess:
        LocalCorrectionsSubProcessor.addUnqualifiedFieldAccessProposal(context, problem, proposals);
        break;
    case IProblem.Task:
        proposals.add(new TaskMarkerProposal(context.getCompilationUnit(), problem, 10));
        break;
    case IProblem.JavadocMissing:
        JavadocTagsSubProcessor.getMissingJavadocCommentProposals(context, problem, proposals);
        break;
    case IProblem.JavadocMissingParamTag:
    case IProblem.JavadocMissingReturnTag:
    case IProblem.JavadocMissingThrowsTag:
        JavadocTagsSubProcessor.getMissingJavadocTagProposals(context, problem, proposals);
        break;
    case IProblem.JavadocInvalidThrowsClassName:
    case IProblem.JavadocDuplicateThrowsClassName:
    case IProblem.JavadocDuplicateReturnTag:
    case IProblem.JavadocDuplicateParamName:
    case IProblem.JavadocInvalidParamName:
    case IProblem.JavadocUnexpectedTag:
    case IProblem.JavadocInvalidTag:
        JavadocTagsSubProcessor.getRemoveJavadocTagProposals(context, problem, proposals);
        break;
    case IProblem.LocalVariableHidingLocalVariable:
    case IProblem.LocalVariableHidingField:
    case IProblem.FieldHidingLocalVariable:
    case IProblem.FieldHidingField:
    case IProblem.ArgumentHidingLocalVariable:
    case IProblem.ArgumentHidingField:
    case IProblem.UseAssertAsAnIdentifier:
    case IProblem.UseEnumAsAnIdentifier:
    case IProblem.RedefinedLocal:
    case IProblem.RedefinedArgument:
        LocalCorrectionsSubProcessor.addInvalidVariableNameProposals(context, problem, proposals);
        break;
    case IProblem.NoMessageSendOnArrayType:
        UnresolvedElementsSubProcessor.getArrayAccessProposals(context, problem, proposals);
        break;
    case IProblem.InvalidOperator:
        LocalCorrectionsSubProcessor.getInvalidOperatorProposals(context, problem, proposals);
        break;
    case IProblem.MissingSerialVersion:
        SerialVersionSubProcessor.getSerialVersionProposals(context, problem, proposals);
        break;
    case IProblem.UnnecessaryElse:
        LocalCorrectionsSubProcessor.getUnnecessaryElseProposals(context, problem, proposals);
        break;
    case IProblem.SuperclassMustBeAClass:
        LocalCorrectionsSubProcessor.getInterfaceExtendsClassProposals(context, problem, proposals);
        break;
    case IProblem.CodeCannotBeReached:
        LocalCorrectionsSubProcessor.getUnreachableCodeProposals(context, problem, proposals);
        break;
    case IProblem.InvalidUsageOfTypeParameters:
    case IProblem.InvalidUsageOfStaticImports:
    case IProblem.InvalidUsageOfForeachStatements:
    case IProblem.InvalidUsageOfTypeArguments:
    case IProblem.InvalidUsageOfEnumDeclarations:
    case IProblem.InvalidUsageOfVarargs:
    case IProblem.InvalidUsageOfAnnotations:
    case IProblem.InvalidUsageOfAnnotationDeclarations:
        // FICXADE  Need reflection here!
        // ECLIPSE 3.8
        //                ReorgCorrectionsSubProcessor.getNeedHigherComplianceProposals(context, problem, proposals, JavaCore.VERSION_1_5);
        // ORIG
        //                ReorgCorrectionsSubProcessor.getNeed50ComplianceProposals(context, problem, proposals);
        break;
    case IProblem.NonGenericType:
        TypeArgumentMismatchSubProcessor.removeMismatchedArguments(context, problem, proposals);
        break;
    case IProblem.MissingOverrideAnnotation:
        ModifierCorrectionSubProcessor.addOverrideAnnotationProposal(context, problem, proposals);
        break;
    case IProblem.FieldMissingDeprecatedAnnotation:
    case IProblem.MethodMissingDeprecatedAnnotation:
    case IProblem.TypeMissingDeprecatedAnnotation:
        ModifierCorrectionSubProcessor.addDeprecatedAnnotationProposal(context, problem, proposals);
        break;
    case IProblem.IsClassPathCorrect:
        ReorgCorrectionsSubProcessor.getIncorrectBuildPathProposals(context, problem, proposals);
        break;
    case IProblem.ForbiddenReference:
    case IProblem.DiscouragedReference:
        ReorgCorrectionsSubProcessor.getAccessRulesProposals(context, problem, proposals);
        break;
    case IProblem.AssignmentHasNoEffect:
        LocalCorrectionsSubProcessor.getAssignmentHasNoEffectProposals(context, problem, proposals);
        break;
    case IProblem.UnsafeTypeConversion:
    case IProblem.RawTypeReference:
    case IProblem.UnsafeRawMethodInvocation:
        LocalCorrectionsSubProcessor.addTypePrametersToRawTypeReference(context, problem, proposals);
        break;
    case IProblem.FallthroughCase:
        LocalCorrectionsSubProcessor.addFallThroughProposals(context, problem, proposals);
        break;
    case IProblem.UnhandledWarningToken:
        SuppressWarningsSubProcessor.addUnknownSuppressWarningProposals(context, problem, proposals);
        break;
    default:
    }
    if (JavaModelUtil.is50OrHigher(context.getCompilationUnit().getJavaProject())) {
        SuppressWarningsSubProcessor.addSuppressWarningsProposals(context, problem, proposals);
    }
}

From source file:org.eclipse.ajdt.internal.ui.wizards.NewTypeWizardPage.java

License:Open Source License

private void removeUnusedImports(ICompilationUnit cu, Set existingImports, boolean needsSave)
        throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS8);
    parser.setSource(cu);// ww w . j a  v a  2s .c  o  m
    parser.setResolveBindings(true);

    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    if (root.getProblems().length == 0) {
        return;
    }

    List importsDecls = root.imports();
    if (importsDecls.isEmpty()) {
        return;
    }
    ImportsManager imports = new ImportsManager(root);

    int importsEnd = ASTNodes.getExclusiveEnd((ASTNode) importsDecls.get(importsDecls.size() - 1));
    IProblem[] problems = root.getProblems();
    for (int i = 0; i < problems.length; i++) {
        IProblem curr = problems[i];
        if (curr.getSourceEnd() < importsEnd) {
            int id = curr.getID();
            if (id == IProblem.UnusedImport || id == IProblem.NotVisibleType) { // not visible problems hide unused -> remove both
                int pos = curr.getSourceStart();
                for (int k = 0; k < importsDecls.size(); k++) {
                    ImportDeclaration decl = (ImportDeclaration) importsDecls.get(k);
                    if (decl.getStartPosition() <= pos && pos < decl.getStartPosition() + decl.getLength()) {
                        if (existingImports.isEmpty() || !existingImports.contains(ASTNodes.asString(decl))) {
                            String name = decl.getName().getFullyQualifiedName();
                            if (decl.isOnDemand()) {
                                name += ".*"; //$NON-NLS-1$
                            }
                            if (decl.isStatic()) {
                                imports.removeStaticImport(name);
                            } else {
                                imports.removeImport(name);
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    imports.create(needsSave, null);
}

From source file:org.eclipse.e4.tools.ui.designer.utils.ASTHelper.java

License:Open Source License

private static void removeUnusedImports(ICompilationUnit cu, Set existingImports, boolean needsSave)
        throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(cu);/*www  .j  a  va 2  s . c  om*/
    parser.setResolveBindings(true);

    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    if (root.getProblems().length == 0) {
        return;
    }

    List importsDecls = root.imports();
    if (importsDecls.isEmpty()) {
        return;
    }
    ImportsManager imports = new ImportsManager(root);

    int importsEnd = ASTNodes.getExclusiveEnd((ASTNode) importsDecls.get(importsDecls.size() - 1));
    IProblem[] problems = root.getProblems();
    for (int i = 0; i < problems.length; i++) {
        IProblem curr = problems[i];
        if (curr.getSourceEnd() < importsEnd) {
            int id = curr.getID();
            if (id == IProblem.UnusedImport || id == IProblem.NotVisibleType) { // not visible
                // problems hide
                // unused -> remove
                // both
                int pos = curr.getSourceStart();
                for (int k = 0; k < importsDecls.size(); k++) {
                    ImportDeclaration decl = (ImportDeclaration) importsDecls.get(k);
                    if (decl.getStartPosition() <= pos && pos < decl.getStartPosition() + decl.getLength()) {
                        if (existingImports.isEmpty() || !existingImports.contains(ASTNodes.asString(decl))) {
                            String name = decl.getName().getFullyQualifiedName();
                            if (decl.isOnDemand()) {
                                name += ".*"; //$NON-NLS-1$
                            }
                            if (decl.isStatic()) {
                                imports.removeStaticImport(name);
                            } else {
                                imports.removeImport(name);
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    imports.create(needsSave, null);
}

From source file:org.eclipse.e4.xwt.ui.editor.jdt.ASTHelper.java

License:Open Source License

private void removeUnusedImports(ICompilationUnit cu, Set existingImports, boolean needsSave)
        throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(cu);//from  w  ww. j  a v a 2  s.co  m
    parser.setResolveBindings(true);

    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    if (root.getProblems().length == 0) {
        return;
    }

    List importsDecls = root.imports();
    if (importsDecls.isEmpty()) {
        return;
    }
    ImportsManager imports = new ImportsManager(root);

    int importsEnd = ASTNodes.getExclusiveEnd((ASTNode) importsDecls.get(importsDecls.size() - 1));
    IProblem[] problems = root.getProblems();
    for (int i = 0; i < problems.length; i++) {
        IProblem curr = problems[i];
        if (curr.getSourceEnd() < importsEnd) {
            int id = curr.getID();
            if (id == IProblem.UnusedImport || id == IProblem.NotVisibleType) { // not visible
                // problems hide
                // unused -> remove
                // both
                int pos = curr.getSourceStart();
                for (int k = 0; k < importsDecls.size(); k++) {
                    ImportDeclaration decl = (ImportDeclaration) importsDecls.get(k);
                    if (decl.getStartPosition() <= pos && pos < decl.getStartPosition() + decl.getLength()) {
                        if (existingImports.isEmpty() || !existingImports.contains(ASTNodes.asString(decl))) {
                            String name = decl.getName().getFullyQualifiedName();
                            if (decl.isOnDemand()) {
                                name += ".*"; //$NON-NLS-1$
                            }
                            if (decl.isStatic()) {
                                imports.removeStaticImport(name);
                            } else {
                                imports.removeImport(name);
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    imports.create(needsSave, null);
}

From source file:org.eclipse.jst.jsp.core.internal.validation.JSPJavaValidator.java

License:Open Source License

/**
 * Creates an IMessage from asn IProblem
 * /*  w ww . j  av  a  2 s  .  co m*/
 * @param problem
 * @param f
 * @param translation
 * @param structuredDoc
 * @return message representation of the problem, or null if it could not
 *         create one
 */
private IMessage createMessageFromProblem(IProblem problem, IFile f, IJSPTranslation translation,
        IStructuredDocument structuredDoc) {
    int sev = -1;
    int sourceStart = -1;
    int sourceEnd = -1;

    if (problem instanceof IJSPProblem) {
        sourceStart = problem.getSourceStart();
        sourceEnd = problem.getSourceEnd();
        switch (((IJSPProblem) problem).getEID()) {
        case IJSPProblem.TEIClassNotFound:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_TEI_CLASS_NOT_FOUND);
            break;
        case IJSPProblem.TEIValidationMessage:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_TEI_VALIDATION_MESSAGE);
            break;
        case IJSPProblem.TEIClassNotInstantiated:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_TEI_CLASS_NOT_INSTANTIATED);
            break;
        case IJSPProblem.TEIClassMisc:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_TEI_CLASS_RUNTIME_EXCEPTION);
            break;
        case IJSPProblem.TagClassNotFound:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_TAG_HANDLER_CLASS_NOT_FOUND);
            break;
        case IJSPProblem.UseBeanInvalidID:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_USEBEAN_INVALID_ID);
            break;
        case IJSPProblem.UseBeanMissingTypeInfo:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_USBEAN_MISSING_TYPE_INFO);
            break;
        case IJSPProblem.UseBeanAmbiguousType:
            sev = getMessageSeverity(JSPCorePreferenceNames.VALIDATION_TRANSLATION_USEBEAN_AMBIGUOUS_TYPE_INFO);
            break;
        default:
            sev = problem.isError() ? IMessage.HIGH_SEVERITY
                    : (problem.isWarning() ? IMessage.NORMAL_SEVERITY : ValidationMessage.IGNORE);

        }
    } else {
        sourceStart = translation.getJspOffset(problem.getSourceStart());
        sourceEnd = translation.getJspOffset(problem.getSourceEnd());
        switch (problem.getID()) {
        case IProblem.LocalVariableIsNeverUsed: {
            sev = getSourceSeverity(JSPCorePreferenceNames.VALIDATION_JAVA_LOCAL_VARIABLE_NEVER_USED,
                    sourceStart, sourceEnd);
        }
            break;
        case IProblem.NullLocalVariableReference: {
            sev = getSourceSeverity(JSPCorePreferenceNames.VALIDATION_JAVA_NULL_LOCAL_VARIABLE_REFERENCE,
                    sourceStart, sourceEnd);
        }
            break;
        case IProblem.ArgumentIsNeverUsed: {
            sev = getSourceSeverity(JSPCorePreferenceNames.VALIDATION_JAVA_ARGUMENT_IS_NEVER_USED, sourceStart,
                    sourceEnd);
        }
            break;
        case IProblem.PotentialNullLocalVariableReference: {
            sev = getSourceSeverity(
                    JSPCorePreferenceNames.VALIDATION_JAVA_POTENTIAL_NULL_LOCAL_VARIABLE_REFERENCE, sourceStart,
                    sourceEnd);
        }
            break;
        case IProblem.UnusedImport: {
            sev = getSourceSeverity(JSPCorePreferenceNames.VALIDATION_JAVA_UNUSED_IMPORT, sourceStart,
                    sourceEnd);
        }
            break;
        case IProblem.UnusedPrivateField:
        case IProblem.MissingSerialVersion: {
            // JSP files don't get serialized...right?
            sev = ValidationMessage.IGNORE;
        }
            break;

        default: {
            if (problem.isError()) {
                sev = IMessage.HIGH_SEVERITY;
            } else if (problem.isWarning()) {
                sev = IMessage.NORMAL_SEVERITY;
            } else {
                sev = IMessage.LOW_SEVERITY;
            }
        }
            if (sev == ValidationMessage.IGNORE) {
                return null;
            }

            /* problems without JSP positions are in generated code */
            if (sourceStart == -1) {
                int problemID = problem.getID();
                /*
                 * Quoting IProblem doc: "When a problem is tagged as
                 * Internal, it means that no change other than a
                 * local source code change can fix the corresponding
                 * problem." Assuming that our generated code is
                 * correct, that should reduce the reported problems
                 * to those the user can correct.
                 */
                if (((problemID & IProblem.Internal) != 0) && ((problemID & IProblem.Syntax) != 0)
                        && translation instanceof JSPTranslation) {
                    // Attach to the last code scripting section
                    JSPTranslation jspTranslation = ((JSPTranslation) translation);
                    Position[] jspPositions = (Position[]) jspTranslation.getJsp2JavaMap().keySet()
                            .toArray(new Position[jspTranslation.getJsp2JavaMap().size()]);
                    for (int i = 0; i < jspPositions.length; i++) {
                        sourceStart = Math.max(sourceStart, jspPositions[i].getOffset());
                    }
                    IMessage m = new LocalizedMessage(sev, problem.getMessage(), f);
                    m.setOffset(sourceStart);
                    m.setLength(1);
                    return m;
                } else {
                    return null;
                }
            }
        }
    }
    if (sev == ValidationMessage.IGNORE) {
        return null;
    }

    final boolean isIndirect = translation.isIndirect(problem.getSourceStart());
    if (isIndirect && !FragmentValidationTools.shouldValidateFragment(f)) {
        return null;
    }

    // line number for marker starts @ 1
    // line number from document starts @ 0
    int lineNo = structuredDoc.getLineOfOffset(sourceStart) + 1;

    IMessage m = new LocalizedMessage(sev, problem.getMessage(), f);

    m.setLineNo(lineNo);
    m.setOffset(sourceStart);
    m.setLength((sourceEnd >= sourceStart) ? (sourceEnd - sourceStart + 1) : 0);

    // need additional adjustment for problems from
    // indirect (included) files
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=119633
    if (isIndirect) {
        adjustIndirectPosition(m, translation);
    }

    return m;
}

From source file:org.eclipse.objectteams.otdt.internal.ui.wizards.typecreation.TypeCreator.java

License:Open Source License

private void removeUnusedImports(ICompilationUnit cu, Set<String> existingImports, boolean needsSave)
        throws CoreException {
    ASTParser parser = ASTParser.newParser(AST.JLS4);
    parser.setSource(cu);/* ww w  . j  a v  a2  s . c o m*/
    parser.setResolveBindings(true);

    CompilationUnit root = (CompilationUnit) parser.createAST(null);
    if (root.getProblems().length == 0) {
        return;
    }

    List importsDecls = root.imports();
    if (importsDecls.isEmpty()) {
        return;
    }
    ImportsManager imports = new ImportsManager(root);

    int importsEnd = ASTNodes.getExclusiveEnd((ASTNode) importsDecls.get(importsDecls.size() - 1));
    IProblem[] problems = root.getProblems();
    for (int i = 0; i < problems.length; i++) {
        IProblem curr = problems[i];
        if (curr.getSourceEnd() < importsEnd) {
            int id = curr.getID();
            if (id == IProblem.UnusedImport || id == IProblem.NotVisibleType) { // not visible problems hide unused -> remove both
                int pos = curr.getSourceStart();
                for (int k = 0; k < importsDecls.size(); k++) {
                    ImportDeclaration decl = (ImportDeclaration) importsDecls.get(k);
                    if (decl.getStartPosition() <= pos && pos < decl.getStartPosition() + decl.getLength()) {
                        if (existingImports.isEmpty() || !existingImports.contains(ASTNodes.asString(decl))) {
                            String name = decl.getName().getFullyQualifiedName();
                            if (decl.isOnDemand()) {
                                name += ".*"; //$NON-NLS-1$
                            }
                            if (decl.isStatic()) {
                                imports.removeStaticImport(name);
                            } else {
                                imports.removeImport(name);
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    imports.create(needsSave, null);
}