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

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

Introduction

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

Prototype

int UnterminatedString

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

Click Source Link

Usage

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  ww  w  .j a  va2 s.co 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;/*from  w  w w  . j  ava 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);
    }
}

From source file:processing.mode.java.pdex.CompileErrorMessageSimplifier.java

License:Open Source License

/**
 * Tones down the jargon in the ecj reported errors.
 *///  w w  w. ja va 2s. c  o m
public static String getSimplifiedErrorMessage(IProblem iprob, String badCode) {
    if (iprob == null)
        return null;

    String args[] = iprob.getArguments();

    if (DEBUG) {
        Messages.log("Simplifying message: " + iprob.getMessage() + " ID: " + getIDName(iprob.getID()));
        Messages.log("Arg count: " + args.length);
        for (String arg : args) {
            Messages.log("Arg " + arg);
        }
        Messages.log("Bad code: " + badCode);
    }

    String result = null;

    switch (iprob.getID()) {

    case IProblem.ParsingError:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.error_on", args[0]);
        }
        break;

    case IProblem.ParsingErrorDeleteToken:
        if (args.length > 0) {
            if (args[0].equalsIgnoreCase("Invalid Character")) {
                result = getErrorMessageForCurlyQuote(badCode);
            }
        }
        break;

    case IProblem.ParsingErrorDeleteTokens:
        result = getErrorMessageForCurlyQuote(badCode);
        if (result == null) {
            result = Language.interpolate("editor.status.error_on", args[0]);
        }
        break;

    case IProblem.ParsingErrorInsertToComplete:
        if (args.length > 0) {
            if (args[0].length() == 1) {
                result = getErrorMessageForBracket(args[0].charAt(0));

            } else {
                if (args[0].equals("AssignmentOperator Expression")) {
                    result = Language.interpolate("editor.status.missing.add", "=");

                } else if (args[0].equalsIgnoreCase(") Statement")) {
                    result = getErrorMessageForBracket(args[0].charAt(0));

                } else {
                    result = Language.interpolate("editor.status.error_on", args[0]);
                }
            }
        }
        break;

    case IProblem.ParsingErrorInvalidToken:
        if (args.length > 0) {
            if (args[0].equals("int")) {
                if (args[1].equals("VariableDeclaratorId")) {
                    result = Language.text("editor.status.reserved_words");
                } else {
                    result = Language.interpolate("editor.status.error_on", args[0]);
                }
            } else if (args[0].equalsIgnoreCase("Invalid Character")) {
                result = getErrorMessageForCurlyQuote(badCode);
            }
            if (result == null) {
                result = Language.interpolate("editor.status.error_on", args[0]);
            }
        }
        break;

    case IProblem.ParsingErrorInsertTokenAfter:
        if (args.length > 0) {
            if (args[1].length() == 1) {
                result = getErrorMessageForBracket(args[1].charAt(0));
            } else {
                // https://github.com/processing/processing/issues/3104
                if (args[1].equalsIgnoreCase("Statement")) {
                    result = Language.interpolate("editor.status.error_on", args[0]);
                } else {
                    result = Language.interpolate("editor.status.error_on", args[0]) + " "
                            + Language.interpolate("editor.status.missing.add", args[1]);
                }
            }
        }
        break;

    case IProblem.ParsingErrorReplaceTokens:
        result = getErrorMessageForCurlyQuote(badCode);

    case IProblem.UndefinedConstructor:
        if (args.length == 2) {
            String constructorName = args[0];
            // For messages such as "contructor sketch_name.ClassXYZ() is undefined", change
            // constructor name to "ClassXYZ()". See #3434
            if (constructorName.contains(".")) {
                // arg[0] contains sketch name twice: sketch_150705a.sketch_150705a.Thing
                constructorName = constructorName.substring(constructorName.indexOf('.') + 1);
                constructorName = constructorName.substring(constructorName.indexOf('.') + 1);
            }
            String constructorArgs = removePackagePrefixes(args[args.length - 1]);
            result = Language.interpolate("editor.status.undefined_constructor", constructorName,
                    constructorArgs);
        }
        break;

    case IProblem.UndefinedMethod:
        if (args.length > 2) {
            String methodName = args[args.length - 2];
            String methodArgs = removePackagePrefixes(args[args.length - 1]);
            result = Language.interpolate("editor.status.undefined_method", methodName, methodArgs);
        }
        break;

    case IProblem.ParameterMismatch:
        if (args.length > 3) {
            // 2nd arg is method name, 3rd arg is correct param list
            if (args[2].trim().length() == 0) {
                // the case where no params are needed.
                result = Language.interpolate("editor.status.empty_param", args[1]);

            } else {
                result = Language.interpolate("editor.status.wrong_param", args[1], args[1],
                        removePackagePrefixes(args[2]));
                //          String method = q(args[1]);
                //          String methodDef = " \"" + args[1] + "(" + getSimpleName(args[2]) + ")\"";
                //          result = result.replace("method", method);
                //          result += methodDef;
            }
        }
        break;

    case IProblem.UndefinedField:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.undef_global_var", args[0]);
        }
        break;

    case IProblem.UndefinedType:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.undef_class", args[0]);
        }
        break;

    case IProblem.UnresolvedVariable:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.undef_var", args[0]);
        }
        break;

    case IProblem.UndefinedName:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.undef_name", args[0]);
        }
        break;

    case IProblem.UnterminatedString:
        if (badCode.contains("") || badCode.contains("?")) {
            result = Language.interpolate("editor.status.unterm_string_curly",
                    badCode.replaceAll("[^?]", ""));
        }
        break;

    case IProblem.TypeMismatch:
        if (args.length > 1) {
            result = Language.interpolate("editor.status.type_mismatch", args[0], args[1]);
            //        result = result.replace("typeA", q(args[0]));
            //        result = result.replace("typeB", q(args[1]));
        }
        break;

    case IProblem.LocalVariableIsNeverUsed:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.unused_variable", args[0]);
        }
        break;

    case IProblem.UninitializedLocalVariable:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.uninitialized_variable", args[0]);
        }
        break;

    case IProblem.AssignmentHasNoEffect:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.no_effect_assignment", args[0]);
        }
        break;

    case IProblem.HidingEnclosingType:
        if (args.length > 0) {
            result = Language.interpolate("editor.status.hiding_enclosing_type", args[0]);
        }
        break;
    }

    if (result == null) {
        String message = iprob.getMessage();
        if (message != null) {
            // Remove all instances of token
            // "Syntax error on token 'blah', delete this token"
            Matcher matcher = tokenRegExp.matcher(message);
            message = matcher.replaceAll("");
            result = message;
        }
    }

    if (DEBUG) {
        Messages.log("Simplified Error Msg: " + result);
    }

    return result;
}