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

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

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

Introduction

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

Prototype

int RawTypeReference

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

Click Source Link

Usage

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;//from  ww  w . ja v a  2  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);
    }
}