List of usage examples for org.eclipse.jdt.core.compiler IProblem NotVisibleMethod
int NotVisibleMethod
To view the source code for org.eclipse.jdt.core.compiler IProblem NotVisibleMethod.
Click Source Link
From source file:com.facebook.nuclide.debugger.EvaluationManager.java
License:Open Source License
private String checkUnitForProblems(CompilationUnit unit) { final IProblem[] problems = unit.getProblems(); final StringBuilder errors = new StringBuilder(); int realProblemCount = 0; if (problems.length > 0) { for (IProblem problem : problems) { if (!problem.isError()) { // Ignore anything that's not error severity. continue; }//from w w w .j a va 2s. c o m int problemId = problem.getID(); // These problems do not need to stop the parse. // NOTE: List taken from Eclipse reference impl. if (problemId == IProblem.VoidMethodReturnsValue || problemId == IProblem.NotVisibleMethod || problemId == IProblem.NotVisibleConstructor || problemId == IProblem.NotVisibleField || problemId == IProblem.NotVisibleType || problemId == IProblem.ImportNotFound || problemId == IProblem.UndefinedType || problemId == IProblem.BodyForAbstractMethod) { continue; } realProblemCount++; if (realProblemCount == 1) { errors.append("Unable to evaluate expression: "); } errors.append(problem.getMessage()); errors.append("\n"); } // We couldn't parse the specified expression. // Throw the error messages back to the debugger frontend. if (realProblemCount > 0) { return errors.toString().trim(); } } return null; }
From source file:org.eclipse.ajdt.core.parserbridge.AJCompilationUnitProblemFinder.java
License:Open Source License
public static boolean isARealProblem(CategorizedProblem categorizedProblem, CompilationUnit unit, AJProjectModelFacade model, boolean hasModel, boolean isJavaFileInAJEditor) { int numArgs = categorizedProblem.getArguments() == null ? 0 : categorizedProblem.getArguments().length; String firstArg = numArgs > 0 ? categorizedProblem.getArguments()[0] : null; String secondArg = numArgs > 1 ? categorizedProblem.getArguments()[1] : null; int id = categorizedProblem.getID(); if (!hasModel && (id == IProblem.UndefinedType || id == IProblem.UndefinedName || id == IProblem.UnresolvedVariable || // AJDT 3.6 id == IProblem.UndefinedField || id == IProblem.UndefinedMethod || id == IProblem.UndefinedConstructor || id == IProblem.IllegalCast || id == IProblem.AbstractMethodMustBeImplemented) // anonymous interface with ITDs implementing abstract method ) {/*from w w w . j a v a2 s.com*/ // if there is no model, don't take any chances. // everything that might be an ITD reference is ignored return false; } if (categorizedProblem.getSourceStart() == 0) { // a place for all problems that don't have source locations // because they come from ITDs return false; } if (numArgs > 0 && id == IProblem.UndefinedMethod && (extraAspectMethods.contains(firstArg)) || extraAspectMethods.contains(secondArg)) { // probably hasAspect or aspectOf return false; } if (numArgs > 1 && (id == IProblem.DuplicateField || id == IProblem.DuplicateMethod) && (aspectMemberNames.contains(firstArg) || aspectMemberNames.contains(secondArg)) || declareAnnotationKinds.contains(firstArg) || declareAnnotationKinds.contains(secondArg)) { // declare statement if more than one exist in a file // or around advice if more than one of the same kind exists in the aspect return false; } if (numArgs > 1 && id == IProblem.DuplicateMethod && isTranslatedAdviceName(firstArg, secondArg)) { // more than one before or after advice exists // in same file with same number and types of arguments // as per bug 318132, before and after names are translated // to 'b' and 'a' respectively return false; } if (numArgs == 0 && id == IProblem.MissingReturnType) { // ITD constructors don't have return types // check the name to see if there is a $ in it String problemRegion = extractProblemRegion(categorizedProblem, unit); if (problemRegion.indexOf("$") != -1) { return false; } String[] parts = problemRegion.split("\\("); String name = parts[0].trim(); if (aspectMemberNames.contains(name)) { // advice---before or after return false; } } if (numArgs == 0 && id == IProblem.InvalidExplicitConstructorCall) { // ITD constructor making explicit this() call. // lots of potential for false negatives return false; } if (numArgs == 0 && id == IProblem.MethodRequiresBody) { // Likely to be a pointcut definition return false; } if (numArgs == 2 && id == IProblem.ParsingErrorInsertToComplete && firstArg.equals(";") && secondArg.equals("FieldDeclaration")) { // might be a declare statement String problemRegion = extractProblemRegion(categorizedProblem, unit); if (aspectMemberNames.contains(problemRegion)) { return false; } } // this one is not used any more since the '@' is being removed from the text // if (numArgs == 1 && // id == IProblem.ParsingErrorDeleteToken && // firstArg.equals("@")) { // // likely to be declare annotation declaration // // declare @type, declare @constructor, declare @method, declare @field // String problemRegion = extractNextJavaIdentifier(unit, categorizedProblem.getSourceEnd()); // if (declareAnnotationKinds.contains(problemRegion)) { // return false; // } // } if (numArgs == 1 && id == IProblem.UndefinedType && declareAnnotationKinds.contains(firstArg)) { // alternate error of declare annotations return false; } if (numArgs == 1 && id == IProblem.UndefinedType && firstArg.equals("declare")) { // from a declare declaration return false; } if (numArgs == 1 && id == IProblem.UndefinedType && firstArg.equals("pointcut")) { // from a pointcut declaration return false; } if (numArgs > 0 && (id == IProblem.UndefinedName || id == IProblem.UnresolvedVariable || // AJDT 3.6 id == IProblem.UndefinedField || id == IProblem.UndefinedMethod || id == IProblem.UndefinedType || id == IProblem.UndefinedConstructor) && isITDName(categorizedProblem, unit, model, isJavaFileInAJEditor)) { // a reference inside an aspect to an ITD that it declares return false; } if (hasModel && id == IProblem.ShouldReturnValue && categorizedProblem.getSourceStart() == 0 && categorizedProblem.getSourceEnd() == 0) { // from an inserted ITD that has already been removed // this problem comes because the bodies of the ITDs inserted by ITDInserter // are always empty even when there should be a return value return false; } if (hasModel && (id == IProblem.NotVisibleType || id == IProblem.MethodReducesVisibility) && categorizedProblem.getSourceStart() == 0) { // declare parents type that is not visible by current // type. this is fine as long as it is visible // in the scope of the declare parents declaration. return false; } if ((id == IProblem.NotVisibleConstructor || id == IProblem.NotVisibleField || id == IProblem.NotVisibleMethod || id == IProblem.NotVisibleType) && isPrivilegedAspect(categorizedProblem, unit, isJavaFileInAJEditor)) { // a privileged aspect should be able to see all private/protected members return false; } try { if (numArgs > 1 && id == IProblem.DuplicateMethod && simpleNamesEquals(firstArg, secondArg)) { // bug 280385 // no arg constructor ITD when the target type // has an implicit no arg constructor IJavaElement elt = unit.getElementAt(categorizedProblem.getSourceStart()); // here, check to see if the method name is the same as the // type name. If so, then look for the default constructor, // if none exists, then we can ignore this problem if (elt.getElementType() == IJavaElement.TYPE) { IType type = (IType) elt; if (type.getElementName().equals(firstArg)) { IMethod method = type.getMethod(type.getElementName(), new String[0]); if (!method.exists()) { return false; } } } } if (id == IProblem.ReturnTypeMismatch && numArgs == 2 && typeAtPositionIsArg(categorizedProblem, unit, firstArg)) { if (findLastSegment(getITDTargetType(categorizedProblem, unit, isJavaFileInAJEditor)) .equals(findLastSegment(secondArg))) { // bug 284358 // this problem occurs when 'this' is returned from an ITD method // the resolver thinks there is a type mismath because it was // expecting the aspect type (argument 1) instead of the ITD type // (argument 2) return false; } if (insideITD(categorizedProblem, unit, isJavaFileInAJEditor) && isThisExpression(categorizedProblem, unit)) { // Bug 361170 // Likely a this expresion that is casted to a super type of the ITD return false; } } if (numArgs > 0 && (id == IProblem.UndefinedMethod || id == IProblem.UndefinedName || id == IProblem.UnresolvedVariable) && // AJDT 3.6 (adviceBodyNames.contains(firstArg) || adviceBodyNames.contains(secondArg)) && insideAdvice(categorizedProblem, unit)) { // proceed/thisJoinPoint... statement return false; } if (numArgs == 1 && (id == IProblem.ParsingErrorDeleteToken || id == IProblem.ParsingErrorDeleteTokens) && aspectMemberNames.contains(firstArg) && insideITD(categorizedProblem, unit, isJavaFileInAJEditor)) { // the implements or extends clause of a declare statement return false; } if (id == IProblem.ParameterMismatch && insideITD(categorizedProblem, unit, isJavaFileInAJEditor)) { // Probably a reference to 'this' inside an ITD // compiler thinks 'this' refers to the containing aspect // not the target type return false; } if (id == IProblem.AbstractMethodInAbstractClass && insideITD(categorizedProblem, unit, isJavaFileInAJEditor)) { // an abstract method ITD inside a concrete aspect // ITDs are allowed to be abstract if the target // type is an abstract class, but problem finder does not know this return false; } if (id == IProblem.IllegalAbstractModifierCombinationForMethod && insideITD(categorizedProblem, unit, isJavaFileInAJEditor)) { // private abstract itd in aspect return false; } if (id == IProblem.UnusedPrivateField && (insideITD(categorizedProblem, unit, isJavaFileInAJEditor) || getITDNames(unit, model).size() > 0)) { // private itd is said to be unused, even if it is really used elsewhere // also, if this type has some ITDs, then we really don't know if it is used in the // ITDs, so just be safe and ignore this problem return false; } if (numArgs > 0 && (id == IProblem.UndefinedName || id == IProblem.UnresolvedVariable || // AJDT 3.6 id == IProblem.UndefinedField || id == IProblem.UndefinedMethod || id == IProblem.UndefinedType || id == IProblem.UndefinedConstructor) && insideITD(categorizedProblem, unit, isJavaFileInAJEditor)) { // likely to be a reference inside an ITD to a name in the target type // also will erroneously filter out truly undefined names return false; } if (numArgs > 0 && (id == IProblem.UndefinedType || id == IProblem.InternalTypeNameProvided) && firstArg.indexOf('$') != -1) { // based on previous test, we are not inside of an ITD, // so we may be defining a field or variable with a // type of an inner class using a '.'. // the AspectsConvertingParser converts this '.' into a '$' // ignore. return false; } if (id == IProblem.NonStaticAccessToStaticField && isITDName(categorizedProblem, unit, model, isJavaFileInAJEditor)) { // this is a reference to an ITD field on an interface // compiler thinks that all fields in interfaces are static final return false; } if ((id == IProblem.UnhandledException || id == IProblem.UnhandledExceptionInImplicitConstructorCall || id == IProblem.UnhandledExceptionInDefaultConstructor) && (!model.hasModel() || isSoftened(categorizedProblem, unit, model, isJavaFileInAJEditor))) { return false; } if (id == IProblem.UninitializedBlankFinalField && unit.getElementAt(categorizedProblem.getSourceStart()) == null) { // likely to be inserted dummy fields for organize imports // this only happens when the last declaration is an interface // these dummy fields are implicitly converted to public static final return false; } if (id == IProblem.AbstractMethodsInConcreteClass && isAspect(categorizedProblem, unit, isJavaFileInAJEditor)) { /* AJDT 1.7 */ // an aspect that has an abstract ITD will have this problem // in this case it is a spurious problem. Filter it // unfortunately, this also means filtering real problems // where concrete aspects have abstract methods // new for 1.7 return false; } if (id == IProblem.JavadocMissingReturnTag && insidePointcut(categorizedProblem, unit)) { // pointcuts are parsed as methods with 'pointcut' // as the return type // when JavaDoc checking is set, the parser thinks that // 'pointcut' should have its own javadoc tag return false; } if (numArgs == 1 && id == IProblem.ShouldReturnValue && firstArg.equals("int") && insideAdvice(categorizedProblem, unit)) { // Bug 318132: after keyword is changed to 'int a' to avoid throwing exceptions while // evaluating variables during debug return false; } if ((id == IProblem.InvalidTypeForCollection || id == IProblem.InvalidTypeForCollectionTarget14 || id == IProblem.IncompatibleTypesInConditionalOperator || id == IProblem.IllegalCast) && insideITD(categorizedProblem, unit, isJavaFileInAJEditor) && // I wish there were a more precise way of doing this. Need to // look for a 'this' expression. extractProblemRegion(categorizedProblem, unit).contains("this")) { // Bug 347021 // a 'this' expression in an ITD refers to the target type, not the aspect. // these problems here indicate that the aspect type is being used instead // of the target type. return false; } } catch (JavaModelException e) { } if (id == IProblem.AbstractMethodMustBeImplemented && isITDName(categorizedProblem, unit, model, isJavaFileInAJEditor)) { // a type implements an interface with an ITD method on it return false; } if (id == IProblem.AbstractMethodMustBeImplemented && (!hasModel || isAbstractITD(categorizedProblem, model, unit, isJavaFileInAJEditor))) { // this one is very tricky and rare. // there is a abstract method ITD defined on a supertype // since this type was altered using AspectConvertingParser, // the implementation of this abstract method is not necessarily there return false; } return true; }
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://w w w . j ava2 s . c om 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 w w. j av 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); } }