/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* IBM Corporation - added the following constants
* NonStaticAccessToStaticField
* NonStaticAccessToStaticMethod
* Task
* ExpressionShouldBeAVariable
* AssignmentHasNoEffect
* IBM Corporation - added the following constants
* TooManySyntheticArgumentSlots
* TooManyArrayDimensions
* TooManyBytesForStringConstant
* TooManyMethods
* TooManyFields
* NonBlankFinalLocalAssignment
* ObjectCannotHaveSuperTypes
* MissingSemiColon
* InvalidParenthesizedExpression
* EnclosingInstanceInConstructorCall
* BytecodeExceeds64KLimitForConstructor
* IncompatibleReturnTypeForNonInheritedInterfaceMethod
* UnusedPrivateMethod
* UnusedPrivateConstructor
* UnusedPrivateType
* UnusedPrivateField
* IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
* InvalidExplicitConstructorCall
* IBM Corporation - added the following constants
* PossibleAccidentalBooleanAssignment
* SuperfluousSemicolon
* IndirectAccessToStaticField
* IndirectAccessToStaticMethod
* IndirectAccessToStaticType
* BooleanMethodThrowingException
* UnnecessaryCast
* UnnecessaryArgumentCast
* UnnecessaryInstanceof
* FinallyMustCompleteNormally
* UnusedMethodDeclaredThrownException
* UnusedConstructorDeclaredThrownException
* InvalidCatchBlockSequence
* UnqualifiedFieldAccess
* IBM Corporation - added the following constants
* Javadoc
* JavadocUnexpectedTag
* JavadocMissingParamTag
* JavadocMissingParamName
* JavadocDuplicateParamName
* JavadocInvalidParamName
* JavadocMissingReturnTag
* JavadocDuplicateReturnTag
* JavadocMissingThrowsTag
* JavadocMissingThrowsClassName
* JavadocInvalidThrowsClass
* JavadocDuplicateThrowsClassName
* JavadocInvalidThrowsClassName
* JavadocMissingSeeReference
* JavadocInvalidSeeReference
* JavadocInvalidSeeHref
* JavadocInvalidSeeArgs
* JavadocMissing
* JavadocInvalidTag
* JavadocMessagePrefix
* EmptyControlFlowStatement
* IBM Corporation - added the following constants
* IllegalUsageOfQualifiedTypeReference
* InvalidDigit
* IBM Corporation - added the following constants
* ParameterAssignment
* FallthroughCase
* IBM Corporation - added the following constants
* UnusedLabel
* UnnecessaryNLSTag
* LocalVariableMayBeNull
* EnumConstantsCannotBeSurroundedByParenthesis
* JavadocMissingIdentifier
* JavadocNonStaticTypeFromStaticInvocation
* RawTypeReference
* NoAdditionalBoundAfterTypeVariable
* UnsafeGenericArrayForVarargs
* IllegalAccessFromTypeVariable
* AnnotationValueMustBeArrayInitializer
* InvalidEncoding
* CannotReadSource
* EnumStaticFieldInInInitializerContext
* ExternalProblemNotFixable
* ExternalProblemFixable
* IBM Corporation - added the following constants
* AnnotationValueMustBeAnEnumConstant
* OverridingMethodWithoutSuperInvocation
* MethodMustOverrideOrImplement
* TypeHidingTypeParameterFromType
* TypeHidingTypeParameterFromMethod
* TypeHidingType
* IBM Corporation - added the following constants
* NullLocalVariableReference
* PotentialNullLocalVariableReference
* RedundantNullCheckOnNullLocalVariable
* NullLocalVariableComparisonYieldsFalse
* RedundantLocalVariableNullAssignment
* NullLocalVariableInstanceofYieldsFalse
* RedundantNullCheckOnNonNullLocalVariable
* NonNullLocalVariableComparisonYieldsFalse
* IBM Corporation - added the following constants
* InvalidUsageOfTypeParametersForAnnotationDeclaration
* InvalidUsageOfTypeParametersForEnumDeclaration
* IBM Corporation - added the following constants
* RedundantSuperinterface
* Benjamin Muskalla - added the following constants
* MissingSynchronizedModifierInInheritedMethod
* Stephan Herrmann - added the following constants
* UnusedObjectAllocation
*******************************************************************************/
package org.eclipse.jdt.core.compiler;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
/**
* Description of a Java problem, as detected by the compiler or some of the underlying technology
* reusing the compiler. A problem provides access to:
* <ul>
* <li>its location (originating source file name, source position, line number),</li>
* <li>its message description and a predicate to check its severity (warning or error).</li>
* <li>its ID : a number identifying the very nature of this problem. All possible IDs are listed as
* constants on this interface.</li>
* </ul>
*
* Note: the compiler produces IProblems internally, which are turned into markers by the
* JavaBuilder so as to persist problem descriptions. This explains why there is no API allowing to
* reach IProblem detected when compiling. However, the Java problem markers carry equivalent
* information to IProblem, in particular their ID (attribute "id") is set to one of the IDs defined
* on this interface.
*
* @since 2.0
* @noimplement This interface is not intended to be implemented by clients.
* @noextend This interface is not intended to be extended by clients.
*/
public interface IProblem {
/**
* Answer back the original arguments recorded into the problem.
*
* @return the original arguments recorded into the problem
*/
String[] getArguments();
/**
* Returns the problem id
*
* @return the problem id
*/
int getID();
/**
* Answer a localized, human-readable message string which describes the problem.
*
* @return a localized, human-readable message string which describes the problem
*/
String getMessage();
/**
* Answer the file name in which the problem was found.
*
* @return the file name in which the problem was found
*/
char[] getOriginatingFileName();
/**
* Answer the end position of the problem (inclusive), or -1 if unknown.
*
* @return the end position of the problem (inclusive), or -1 if unknown
*/
int getSourceEnd();
/**
* Answer the line number in source where the problem begins.
*
* @return the line number in source where the problem begins
*/
int getSourceLineNumber();
/**
* Answer the start position of the problem (inclusive), or -1 if unknown.
*
* @return the start position of the problem (inclusive), or -1 if unknown
*/
int getSourceStart();
/**
* Checks the severity to see if the Error bit is set.
*
* @return true if the Error bit is set for the severity, false otherwise
*/
boolean isError();
/**
* Checks the severity to see if the Error bit is not set.
*
* @return true if the Error bit is not set for the severity, false otherwise
*/
boolean isWarning();
/**
* Set the end position of the problem (inclusive), or -1 if unknown. Used for shifting problem
* positions.
*
* @param sourceEnd the given end position
*/
void setSourceEnd(int sourceEnd);
/**
* Set the line number in source where the problem begins.
*
* @param lineNumber the given line number
*/
void setSourceLineNumber(int lineNumber);
/**
* Set the start position of the problem (inclusive), or -1 if unknown. Used for shifting
* problem positions.
*
* @param sourceStart the given start position
*/
void setSourceStart(int sourceStart);
/**
* Problem Categories The high bits of a problem ID contains information about the category of a
* problem. For example, (problemID & TypeRelated) != 0, indicates that this problem is type
* related.
*
* A problem category can help to implement custom problem filters. Indeed, when numerous
* problems are listed, focusing on import related problems first might be relevant.
*
* When a problem is tagged as Internal, it means that no change other than a local source code
* change can fix the corresponding problem. A type related problem could be addressed by
* changing the type involved in it.
*/
int TypeRelated= 0x01000000;
int FieldRelated= 0x02000000;
int MethodRelated= 0x04000000;
int ConstructorRelated= 0x08000000;
int ImportRelated= 0x10000000;
int Internal= 0x20000000;
int Syntax= 0x40000000;
/** @since 3.0 */
int Javadoc= 0x80000000;
/**
* Mask to use in order to filter out the category portion of the problem ID.
*/
int IgnoreCategoriesMask= 0xFFFFFF;
/**
* Below are listed all available problem IDs. Note that this list could be augmented in the
* future, as new features are added to the Java core implementation.
*/
/**
* ID reserved for referencing an internal error inside the JavaCore implementation which may be
* surfaced as a problem associated with the compilation unit which caused it to occur.
*/
int Unclassified= 0;
/**
* General type related problems
*/
int ObjectHasNoSuperclass= TypeRelated + 1;
int UndefinedType= TypeRelated + 2;
int NotVisibleType= TypeRelated + 3;
int AmbiguousType= TypeRelated + 4;
int UsingDeprecatedType= TypeRelated + 5;
int InternalTypeNameProvided= TypeRelated + 6;
/** @since 2.1 */
int UnusedPrivateType= Internal + TypeRelated + 7;
int IncompatibleTypesInEqualityOperator= TypeRelated + 15;
int IncompatibleTypesInConditionalOperator= TypeRelated + 16;
int TypeMismatch= TypeRelated + 17;
/** @since 3.0 */
int IndirectAccessToStaticType= Internal + TypeRelated + 18;
/**
* Inner types related problems
*/
int MissingEnclosingInstanceForConstructorCall= TypeRelated + 20;
int MissingEnclosingInstance= TypeRelated + 21;
int IncorrectEnclosingInstanceReference= TypeRelated + 22;
int IllegalEnclosingInstanceSpecification= TypeRelated + 23;
int CannotDefineStaticInitializerInLocalType= Internal + 24;
int OuterLocalMustBeFinal= Internal + 25;
int CannotDefineInterfaceInLocalType= Internal + 26;
int IllegalPrimitiveOrArrayTypeForEnclosingInstance= TypeRelated + 27;
/** @since 2.1 */
int EnclosingInstanceInConstructorCall= Internal + 28;
int AnonymousClassCannotExtendFinalClass= TypeRelated + 29;
/** @since 3.1 */
int CannotDefineAnnotationInLocalType= Internal + 30;
/** @since 3.1 */
int CannotDefineEnumInLocalType= Internal + 31;
/** @since 3.1 */
int NonStaticContextForEnumMemberType= Internal + 32;
/** @since 3.3 */
int TypeHidingType= TypeRelated + 33;
// variables
int UndefinedName= Internal + FieldRelated + 50;
int UninitializedLocalVariable= Internal + 51;
int VariableTypeCannotBeVoid= Internal + 52;
/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
int VariableTypeCannotBeVoidArray= Internal + 53;
int CannotAllocateVoidArray= Internal + 54;
// local variables
int RedefinedLocal= Internal + 55;
int RedefinedArgument= Internal + 56;
// final local variables
int DuplicateFinalLocalInitialization= Internal + 57;
/** @since 2.1 */
int NonBlankFinalLocalAssignment= Internal + 58;
/** @since 3.2 */
int ParameterAssignment= Internal + 59;
int FinalOuterLocalAssignment= Internal + 60;
int LocalVariableIsNeverUsed= Internal + 61;
int ArgumentIsNeverUsed= Internal + 62;
int BytecodeExceeds64KLimit= Internal + 63;
int BytecodeExceeds64KLimitForClinit= Internal + 64;
int TooManyArgumentSlots= Internal + 65;
int TooManyLocalVariableSlots= Internal + 66;
/** @since 2.1 */
int TooManySyntheticArgumentSlots= Internal + 67;
/** @since 2.1 */
int TooManyArrayDimensions= Internal + 68;
/** @since 2.1 */
int BytecodeExceeds64KLimitForConstructor= Internal + 69;
// fields
int UndefinedField= FieldRelated + 70;
int NotVisibleField= FieldRelated + 71;
int AmbiguousField= FieldRelated + 72;
int UsingDeprecatedField= FieldRelated + 73;
int NonStaticFieldFromStaticInvocation= FieldRelated + 74;
int ReferenceToForwardField= FieldRelated + Internal + 75;
/** @since 2.1 */
int NonStaticAccessToStaticField= Internal + FieldRelated + 76;
/** @since 2.1 */
int UnusedPrivateField= Internal + FieldRelated + 77;
/** @since 3.0 */
int IndirectAccessToStaticField= Internal + FieldRelated + 78;
/** @since 3.0 */
int UnqualifiedFieldAccess= Internal + FieldRelated + 79;
int FinalFieldAssignment= FieldRelated + 80;
int UninitializedBlankFinalField= FieldRelated + 81;
int DuplicateBlankFinalFieldInitialization= FieldRelated + 82;
/** @since 3.6 */
int UnresolvedVariable= FieldRelated + 83;
// variable hiding
/** @since 3.0 */
int LocalVariableHidingLocalVariable= Internal + 90;
/** @since 3.0 */
int LocalVariableHidingField= Internal + FieldRelated + 91;
/** @since 3.0 */
int FieldHidingLocalVariable= Internal + FieldRelated + 92;
/** @since 3.0 */
int FieldHidingField= Internal + FieldRelated + 93;
/** @since 3.0 */
int ArgumentHidingLocalVariable= Internal + 94;
/** @since 3.0 */
int ArgumentHidingField= Internal + 95;
/** @since 3.1 */
int MissingSerialVersion= Internal + 96;
// methods
int UndefinedMethod= MethodRelated + 100;
int NotVisibleMethod= MethodRelated + 101;
int AmbiguousMethod= MethodRelated + 102;
int UsingDeprecatedMethod= MethodRelated + 103;
int DirectInvocationOfAbstractMethod= MethodRelated + 104;
int VoidMethodReturnsValue= MethodRelated + 105;
int MethodReturnsVoid= MethodRelated + 106;
int MethodRequiresBody= Internal + MethodRelated + 107;
int ShouldReturnValue= Internal + MethodRelated + 108;
int MethodButWithConstructorName= MethodRelated + 110;
int MissingReturnType= TypeRelated + 111;
int BodyForNativeMethod= Internal + MethodRelated + 112;
int BodyForAbstractMethod= Internal + MethodRelated + 113;
int NoMessageSendOnBaseType= MethodRelated + 114;
int ParameterMismatch= MethodRelated + 115;
int NoMessageSendOnArrayType= MethodRelated + 116;
/** @since 2.1 */
int NonStaticAccessToStaticMethod= Internal + MethodRelated + 117;
/** @since 2.1 */
int UnusedPrivateMethod= Internal + MethodRelated + 118;
/** @since 3.0 */
int IndirectAccessToStaticMethod= Internal + MethodRelated + 119;
/** @since 3.4 */
int MissingTypeInMethod= MethodRelated + 120;
// constructors
/** @since 3.4 */
int MissingTypeInConstructor= ConstructorRelated + 129;
int UndefinedConstructor= ConstructorRelated + 130;
int NotVisibleConstructor= ConstructorRelated + 131;
int AmbiguousConstructor= ConstructorRelated + 132;
int UsingDeprecatedConstructor= ConstructorRelated + 133;
/** @since 2.1 */
int UnusedPrivateConstructor= Internal + MethodRelated + 134;
// explicit constructor calls
int InstanceFieldDuringConstructorInvocation= ConstructorRelated + 135;
int InstanceMethodDuringConstructorInvocation= ConstructorRelated + 136;
int RecursiveConstructorInvocation= ConstructorRelated + 137;
int ThisSuperDuringConstructorInvocation= ConstructorRelated + 138;
/** @since 3.0 */
int InvalidExplicitConstructorCall= ConstructorRelated + Syntax + 139;
// implicit constructor calls
int UndefinedConstructorInDefaultConstructor= ConstructorRelated + 140;
int NotVisibleConstructorInDefaultConstructor= ConstructorRelated + 141;
int AmbiguousConstructorInDefaultConstructor= ConstructorRelated + 142;
int UndefinedConstructorInImplicitConstructorCall= ConstructorRelated + 143;
int NotVisibleConstructorInImplicitConstructorCall= ConstructorRelated + 144;
int AmbiguousConstructorInImplicitConstructorCall= ConstructorRelated + 145;
int UnhandledExceptionInDefaultConstructor= TypeRelated + 146;
int UnhandledExceptionInImplicitConstructorCall= TypeRelated + 147;
// expressions
/** @since 3.6 */
int UnusedObjectAllocation= Internal + 148;
/** @since 3.5 */
int DeadCode= Internal + 149;
int ArrayReferenceRequired= Internal + 150;
int NoImplicitStringConversionForCharArrayExpression= Internal + 151;
// constant expressions
int StringConstantIsExceedingUtf8Limit= Internal + 152;
int NonConstantExpression= Internal + 153;
int NumericValueOutOfRange= Internal + 154;
// cast expressions
int IllegalCast= TypeRelated + 156;
// allocations
int InvalidClassInstantiation= TypeRelated + 157;
int CannotDefineDimensionExpressionsWithInit= Internal + 158;
int MustDefineEitherDimensionExpressionsOrInitializer= Internal + 159;
// operators
int InvalidOperator= Internal + 160;
// statements
int CodeCannotBeReached= Internal + 161;
int CannotReturnInInitializer= Internal + 162;
int InitializerMustCompleteNormally= Internal + 163;
// assert
int InvalidVoidExpression= Internal + 164;
// try
int MaskedCatch= TypeRelated + 165;
int DuplicateDefaultCase= Internal + 166;
int UnreachableCatch= TypeRelated + MethodRelated + 167;
int UnhandledException= TypeRelated + 168;
// switch
int IncorrectSwitchType= TypeRelated + 169;
int DuplicateCase= FieldRelated + 170;
// labelled
int DuplicateLabel= Internal + 171;
int InvalidBreak= Internal + 172;
int InvalidContinue= Internal + 173;
int UndefinedLabel= Internal + 174;
//synchronized
int InvalidTypeToSynchronized= Internal + 175;
int InvalidNullToSynchronized= Internal + 176;
// throw
int CannotThrowNull= Internal + 177;
// assignment
/** @since 2.1 */
int AssignmentHasNoEffect= Internal + 178;
/** @since 3.0 */
int PossibleAccidentalBooleanAssignment= Internal + 179;
/** @since 3.0 */
int SuperfluousSemicolon= Internal + 180;
/** @since 3.0 */
int UnnecessaryCast= Internal + TypeRelated + 181;
/**
* @deprecated - no longer generated, use {@link #UnnecessaryCast} instead
* @since 3.0
*/
int UnnecessaryArgumentCast= Internal + TypeRelated + 182;
/** @since 3.0 */
int UnnecessaryInstanceof= Internal + TypeRelated + 183;
/** @since 3.0 */
int FinallyMustCompleteNormally= Internal + 184;
/** @since 3.0 */
int UnusedMethodDeclaredThrownException= Internal + 185;
/** @since 3.0 */
int UnusedConstructorDeclaredThrownException= Internal + 186;
/** @since 3.0 */
int InvalidCatchBlockSequence= Internal + TypeRelated + 187;
/** @since 3.0 */
int EmptyControlFlowStatement= Internal + TypeRelated + 188;
/** @since 3.0 */
int UnnecessaryElse= Internal + 189;
// inner emulation
int NeedToEmulateFieldReadAccess= FieldRelated + 190;
int NeedToEmulateFieldWriteAccess= FieldRelated + 191;
int NeedToEmulateMethodAccess= MethodRelated + 192;
int NeedToEmulateConstructorAccess= MethodRelated + 193;
/** @since 3.2 */
int FallthroughCase= Internal + 194;
//inherited name hides enclosing name (sort of ambiguous)
int InheritedMethodHidesEnclosingName= MethodRelated + 195;
int InheritedFieldHidesEnclosingName= FieldRelated + 196;
int InheritedTypeHidesEnclosingName= TypeRelated + 197;
/** @since 3.1 */
int IllegalUsageOfQualifiedTypeReference= Internal + Syntax + 198;
// miscellaneous
/** @since 3.2 */
int UnusedLabel= Internal + 199;
int ThisInStaticContext= Internal + 200;
int StaticMethodRequested= Internal + MethodRelated + 201;
int IllegalDimension= Internal + 202;
int InvalidTypeExpression= Internal + 203;
int ParsingError= Syntax + Internal + 204;
int ParsingErrorNoSuggestion= Syntax + Internal + 205;
int InvalidUnaryExpression= Syntax + Internal + 206;
// syntax errors
int InterfaceCannotHaveConstructors= Syntax + Internal + 207;
int ArrayConstantsOnlyInArrayInitializers= Syntax + Internal + 208;
int ParsingErrorOnKeyword= Syntax + Internal + 209;
int ParsingErrorOnKeywordNoSuggestion= Syntax + Internal + 210;
/** @since 3.5 */
int ComparingIdentical= Internal + 211;
int UnmatchedBracket= Syntax + Internal + 220;
int NoFieldOnBaseType= FieldRelated + 221;
int InvalidExpressionAsStatement= Syntax + Internal + 222;
/** @since 2.1 */
int ExpressionShouldBeAVariable= Syntax + Internal + 223;
/** @since 2.1 */
int MissingSemiColon= Syntax + Internal + 224;
/** @since 2.1 */
int InvalidParenthesizedExpression= Syntax + Internal + 225;
/** @since 3.0 */
int ParsingErrorInsertTokenBefore= Syntax + Internal + 230;
/** @since 3.0 */
int ParsingErrorInsertTokenAfter= Syntax + Internal + 231;
/** @since 3.0 */
int ParsingErrorDeleteToken= Syntax + Internal + 232;
/** @since 3.0 */
int ParsingErrorDeleteTokens= Syntax + Internal + 233;
/** @since 3.0 */
int ParsingErrorMergeTokens= Syntax + Internal + 234;
/** @since 3.0 */
int ParsingErrorInvalidToken= Syntax + Internal + 235;
/** @since 3.0 */
int ParsingErrorMisplacedConstruct= Syntax + Internal + 236;
/** @since 3.0 */
int ParsingErrorReplaceTokens= Syntax + Internal + 237;
/** @since 3.0 */
int ParsingErrorNoSuggestionForTokens= Syntax + Internal + 238;
/** @since 3.0 */
int ParsingErrorUnexpectedEOF= Syntax + Internal + 239;
/** @since 3.0 */
int ParsingErrorInsertToComplete= Syntax + Internal + 240;
/** @since 3.0 */
int ParsingErrorInsertToCompleteScope= Syntax + Internal + 241;
/** @since 3.0 */
int ParsingErrorInsertToCompletePhrase= Syntax + Internal + 242;
// scanner errors
int EndOfSource= Syntax + Internal + 250;
int InvalidHexa= Syntax + Internal + 251;
int InvalidOctal= Syntax + Internal + 252;
int InvalidCharacterConstant= Syntax + Internal + 253;
int InvalidEscape= Syntax + Internal + 254;
int InvalidInput= Syntax + Internal + 255;
int InvalidUnicodeEscape= Syntax + Internal + 256;
int InvalidFloat= Syntax + Internal + 257;
int NullSourceString= Syntax + Internal + 258;
int UnterminatedString= Syntax + Internal + 259;
int UnterminatedComment= Syntax + Internal + 260;
int NonExternalizedStringLiteral= Internal + 261;
/** @since 3.1 */
int InvalidDigit= Syntax + Internal + 262;
/** @since 3.1 */
int InvalidLowSurrogate= Syntax + Internal + 263;
/** @since 3.1 */
int InvalidHighSurrogate= Syntax + Internal + 264;
/** @since 3.2 */
int UnnecessaryNLSTag= Internal + 265;
// type related problems
/** @since 3.1 */
int DiscouragedReference= TypeRelated + 280;
int InterfaceCannotHaveInitializers= TypeRelated + 300;
int DuplicateModifierForType= TypeRelated + 301;
int IllegalModifierForClass= TypeRelated + 302;
int IllegalModifierForInterface= TypeRelated + 303;
int IllegalModifierForMemberClass= TypeRelated + 304;
int IllegalModifierForMemberInterface= TypeRelated + 305;
int IllegalModifierForLocalClass= TypeRelated + 306;
/** @since 3.1 */
int ForbiddenReference= TypeRelated + 307;
int IllegalModifierCombinationFinalAbstractForClass= TypeRelated + 308;
int IllegalVisibilityModifierForInterfaceMemberType= TypeRelated + 309;
int IllegalVisibilityModifierCombinationForMemberType= TypeRelated + 310;
int IllegalStaticModifierForMemberType= TypeRelated + 311;
int SuperclassMustBeAClass= TypeRelated + 312;
int ClassExtendFinalClass= TypeRelated + 313;
int DuplicateSuperInterface= TypeRelated + 314;
int SuperInterfaceMustBeAnInterface= TypeRelated + 315;
int HierarchyCircularitySelfReference= TypeRelated + 316;
int HierarchyCircularity= TypeRelated + 317;
int HidingEnclosingType= TypeRelated + 318;
int DuplicateNestedType= TypeRelated + 319;
int CannotThrowType= TypeRelated + 320;
int PackageCollidesWithType= TypeRelated + 321;
int TypeCollidesWithPackage= TypeRelated + 322;
int DuplicateTypes= TypeRelated + 323;
int IsClassPathCorrect= TypeRelated + 324;
int PublicClassMustMatchFileName= TypeRelated + 325;
int MustSpecifyPackage= Internal + 326;
int HierarchyHasProblems= TypeRelated + 327;
int PackageIsNotExpectedPackage= Internal + 328;
/** @since 2.1 */
int ObjectCannotHaveSuperTypes= Internal + 329;
/** @since 3.1 */
int ObjectMustBeClass= Internal + 330;
/** @since 3.4 */
int RedundantSuperinterface= TypeRelated + 331;
/** @since 3.5 */
int ShouldImplementHashcode= TypeRelated + 332;
/** @since 3.5 */
int AbstractMethodsInConcreteClass= TypeRelated + 333;
/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
int SuperclassNotFound= TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int SuperclassNotVisible= TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int SuperclassAmbiguous= TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int SuperclassInternalNameProvided= TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int SuperclassInheritedNameHidesEnclosingName= TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
int InterfaceNotFound= TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int InterfaceNotVisible= TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int InterfaceAmbiguous= TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int InterfaceInternalNameProvided= TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int InterfaceInheritedNameHidesEnclosingName= TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
// field related problems
int DuplicateField= FieldRelated + 340;
int DuplicateModifierForField= FieldRelated + 341;
int IllegalModifierForField= FieldRelated + 342;
int IllegalModifierForInterfaceField= FieldRelated + 343;
int IllegalVisibilityModifierCombinationForField= FieldRelated + 344;
int IllegalModifierCombinationFinalVolatileForField= FieldRelated + 345;
int UnexpectedStaticModifierForField= FieldRelated + 346;
/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
int FieldTypeNotFound= FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int FieldTypeNotVisible= FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int FieldTypeAmbiguous= FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int FieldTypeInternalNameProvided= FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int FieldTypeInheritedNameHidesEnclosingName= FieldRelated + 349 + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354
// method related problems
int DuplicateMethod= MethodRelated + 355;
int IllegalModifierForArgument= MethodRelated + 356;
int DuplicateModifierForMethod= MethodRelated + 357;
int IllegalModifierForMethod= MethodRelated + 358;
int IllegalModifierForInterfaceMethod= MethodRelated + 359;
int IllegalVisibilityModifierCombinationForMethod= MethodRelated + 360;
int UnexpectedStaticModifierForMethod= MethodRelated + 361;
int IllegalAbstractModifierCombinationForMethod= MethodRelated + 362;
int AbstractMethodInAbstractClass= MethodRelated + 363;
int ArgumentTypeCannotBeVoid= MethodRelated + 364;
/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
int ArgumentTypeCannotBeVoidArray= MethodRelated + 365;
/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
int ReturnTypeCannotBeVoidArray= MethodRelated + 366;
int NativeMethodsCannotBeStrictfp= MethodRelated + 367;
int DuplicateModifierForArgument= MethodRelated + 368;
/** @since 3.5 */
int IllegalModifierForConstructor= MethodRelated + 369;
/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
int ArgumentTypeNotFound= MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int ArgumentTypeNotVisible= MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int ArgumentTypeAmbiguous= MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int ArgumentTypeInternalNameProvided= MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int ArgumentTypeInheritedNameHidesEnclosingName= MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
int ExceptionTypeNotFound= MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int ExceptionTypeNotVisible= MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int ExceptionTypeAmbiguous= MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int ExceptionTypeInternalNameProvided= MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int ExceptionTypeInheritedNameHidesEnclosingName= MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
int ReturnTypeNotFound= MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int ReturnTypeNotVisible= MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int ReturnTypeAmbiguous= MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int ReturnTypeInternalNameProvided= MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int ReturnTypeInheritedNameHidesEnclosingName= MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
// import related problems
int ConflictingImport= ImportRelated + 385;
int DuplicateImport= ImportRelated + 386;
int CannotImportPackage= ImportRelated + 387;
int UnusedImport= ImportRelated + 388;
int ImportNotFound= ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
int ImportNotVisible= ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
int ImportAmbiguous= ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
int ImportInternalNameProvided= ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
/**
* @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName}
* instead
*/
int ImportInheritedNameHidesEnclosingName= ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
/** @since 3.1 */
int InvalidTypeForStaticImport= ImportRelated + 391;
// local variable related problems
int DuplicateModifierForVariable= MethodRelated + 395;
int IllegalModifierForVariable= MethodRelated + 396;
/**
* @deprecated - problem is no longer generated, use
* {@link #RedundantNullCheckOnNonNullLocalVariable} instead
*/
int LocalVariableCannotBeNull= Internal + 397; // since 3.3: semantics are LocalVariableRedundantCheckOnNonNull
/**
* @deprecated - problem is no longer generated, use {@link #NullLocalVariableReference},
* {@link #RedundantNullCheckOnNullLocalVariable} or
* {@link #RedundantLocalVariableNullAssignment} instead
*/
int LocalVariableCanOnlyBeNull= Internal + 398; // since 3.3: split with LocalVariableRedundantCheckOnNull depending on context
/**
* @deprecated - problem is no longer generated, use
* {@link #PotentialNullLocalVariableReference} instead
*/
int LocalVariableMayBeNull= Internal + 399;
// method verifier problems
int AbstractMethodMustBeImplemented= MethodRelated + 400;
int FinalMethodCannotBeOverridden= MethodRelated + 401;
int IncompatibleExceptionInThrowsClause= MethodRelated + 402;
int IncompatibleExceptionInInheritedMethodThrowsClause= MethodRelated + 403;
int IncompatibleReturnType= MethodRelated + 404;
int InheritedMethodReducesVisibility= MethodRelated + 405;
int CannotOverrideAStaticMethodWithAnInstanceMethod= MethodRelated + 406;
int CannotHideAnInstanceMethodWithAStaticMethod= MethodRelated + 407;
int StaticInheritedMethodConflicts= MethodRelated + 408;
int MethodReducesVisibility= MethodRelated + 409;
int OverridingNonVisibleMethod= MethodRelated + 410;
int AbstractMethodCannotBeOverridden= MethodRelated + 411;
int OverridingDeprecatedMethod= MethodRelated + 412;
/** @since 2.1 */
int IncompatibleReturnTypeForNonInheritedInterfaceMethod= MethodRelated + 413;
/** @since 2.1 */
int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod= MethodRelated + 414;
/** @since 3.1 */
int IllegalVararg= MethodRelated + 415;
/** @since 3.3 */
int OverridingMethodWithoutSuperInvocation= MethodRelated + 416;
/** @since 3.5 */
int MissingSynchronizedModifierInInheritedMethod= MethodRelated + 417;
/** @since 3.5 */
int AbstractMethodMustBeImplementedOverConcreteMethod= MethodRelated + 418;
/** @since 3.5 */
int InheritedIncompatibleReturnType= MethodRelated + 419;
// code snippet support
int CodeSnippetMissingClass= Internal + 420;
int CodeSnippetMissingMethod= Internal + 421;
int CannotUseSuperInCodeSnippet= Internal + 422;
//constant pool
int TooManyConstantsInConstantPool= Internal + 430;
/** @since 2.1 */
int TooManyBytesForStringConstant= Internal + 431;
// static constraints
/** @since 2.1 */
int TooManyFields= Internal + 432;
/** @since 2.1 */
int TooManyMethods= Internal + 433;
// 1.4 features
// assertion warning
int UseAssertAsAnIdentifier= Internal + 440;
// 1.5 features
int UseEnumAsAnIdentifier= Internal + 441;
/** @since 3.2 */
int EnumConstantsCannotBeSurroundedByParenthesis= Syntax + Internal + 442;
// detected task
/** @since 2.1 */
int Task= Internal + 450;
// local variables related problems, cont'd
/** @since 3.3 */
int NullLocalVariableReference= Internal + 451;
/** @since 3.3 */
int PotentialNullLocalVariableReference= Internal + 452;
/** @since 3.3 */
int RedundantNullCheckOnNullLocalVariable= Internal + 453;
/** @since 3.3 */
int NullLocalVariableComparisonYieldsFalse= Internal + 454;
/** @since 3.3 */
int RedundantLocalVariableNullAssignment= Internal + 455;
/** @since 3.3 */
int NullLocalVariableInstanceofYieldsFalse= Internal + 456;
/** @since 3.3 */
int RedundantNullCheckOnNonNullLocalVariable= Internal + 457;
/** @since 3.3 */
int NonNullLocalVariableComparisonYieldsFalse= Internal + 458;
// block
/** @since 3.0 */
int UndocumentedEmptyBlock= Internal + 460;
/*
* Javadoc comments
*/
/**
* Problem signaled on an invalid URL reference. Valid syntax example: @see
* "http://www.eclipse.org/"
*
* @since 3.4
*/
int JavadocInvalidSeeUrlReference= Javadoc + Internal + 462;
/**
* Problem warned on missing tag description.
*
* @since 3.4
*/
int JavadocMissingTagDescription= Javadoc + Internal + 463;
/**
* Problem warned on duplicated tag.
*
* @since 3.3
*/
int JavadocDuplicateTag= Javadoc + Internal + 464;
/**
* Problem signaled on an hidden reference due to a too low visibility level.
*
* @since 3.3
*/
int JavadocHiddenReference= Javadoc + Internal + 465;
/**
* Problem signaled on an invalid qualification for member type reference.
*
* @since 3.3
*/
int JavadocInvalidMemberTypeQualification= Javadoc + Internal + 466;
/** @since 3.2 */
int JavadocMissingIdentifier= Javadoc + Internal + 467;
/** @since 3.2 */
int JavadocNonStaticTypeFromStaticInvocation= Javadoc + Internal + 468;
/** @since 3.1 */
int JavadocInvalidParamTagTypeParameter= Javadoc + Internal + 469;
/** @since 3.0 */
int JavadocUnexpectedTag= Javadoc + Internal + 470;
/** @since 3.0 */
int JavadocMissingParamTag= Javadoc + Internal + 471;
/** @since 3.0 */
int JavadocMissingParamName= Javadoc + Internal + 472;
/** @since 3.0 */
int JavadocDuplicateParamName= Javadoc + Internal + 473;
/** @since 3.0 */
int JavadocInvalidParamName= Javadoc + Internal + 474;
/** @since 3.0 */
int JavadocMissingReturnTag= Javadoc + Internal + 475;
/** @since 3.0 */
int JavadocDuplicateReturnTag= Javadoc + Internal + 476;
/** @since 3.0 */
int JavadocMissingThrowsTag= Javadoc + Internal + 477;
/** @since 3.0 */
int JavadocMissingThrowsClassName= Javadoc + Internal + 478;
/** @since 3.0 */
int JavadocInvalidThrowsClass= Javadoc + Internal + 479;
/** @since 3.0 */
int JavadocDuplicateThrowsClassName= Javadoc + Internal + 480;
/** @since 3.0 */
int JavadocInvalidThrowsClassName= Javadoc + Internal + 481;
/** @since 3.0 */
int JavadocMissingSeeReference= Javadoc + Internal + 482;
/** @since 3.0 */
int JavadocInvalidSeeReference= Javadoc + Internal + 483;
/**
* Problem signaled on an invalid URL reference that does not conform to the href syntax. Valid
* syntax example: @see <a href="http://www.eclipse.org/">Eclipse Home Page</a>
*
* @since 3.0
*/
int JavadocInvalidSeeHref= Javadoc + Internal + 484;
/** @since 3.0 */
int JavadocInvalidSeeArgs= Javadoc + Internal + 485;
/** @since 3.0 */
int JavadocMissing= Javadoc + Internal + 486;
/** @since 3.0 */
int JavadocInvalidTag= Javadoc + Internal + 487;
/*
* ID for field errors in Javadoc
*/
/** @since 3.0 */
int JavadocUndefinedField= Javadoc + Internal + 488;
/** @since 3.0 */
int JavadocNotVisibleField= Javadoc + Internal + 489;
/** @since 3.0 */
int JavadocAmbiguousField= Javadoc + Internal + 490;
/** @since 3.0 */
int JavadocUsingDeprecatedField= Javadoc + Internal + 491;
/*
* IDs for constructor errors in Javadoc
*/
/** @since 3.0 */
int JavadocUndefinedConstructor= Javadoc + Internal + 492;
/** @since 3.0 */
int JavadocNotVisibleConstructor= Javadoc + Internal + 493;
/** @since 3.0 */
int JavadocAmbiguousConstructor= Javadoc + Internal + 494;
/** @since 3.0 */
int JavadocUsingDeprecatedConstructor= Javadoc + Internal + 495;
/*
* IDs for method errors in Javadoc
*/
/** @since 3.0 */
int JavadocUndefinedMethod= Javadoc + Internal + 496;
/** @since 3.0 */
int JavadocNotVisibleMethod= Javadoc + Internal + 497;
/** @since 3.0 */
int JavadocAmbiguousMethod= Javadoc + Internal + 498;
/** @since 3.0 */
int JavadocUsingDeprecatedMethod= Javadoc + Internal + 499;
/** @since 3.0 */
int JavadocNoMessageSendOnBaseType= Javadoc + Internal + 500;
/** @since 3.0 */
int JavadocParameterMismatch= Javadoc + Internal + 501;
/** @since 3.0 */
int JavadocNoMessageSendOnArrayType= Javadoc + Internal + 502;
/*
* IDs for type errors in Javadoc
*/
/** @since 3.0 */
int JavadocUndefinedType= Javadoc + Internal + 503;
/** @since 3.0 */
int JavadocNotVisibleType= Javadoc + Internal + 504;
/** @since 3.0 */
int JavadocAmbiguousType= Javadoc + Internal + 505;
/** @since 3.0 */
int JavadocUsingDeprecatedType= Javadoc + Internal + 506;
/** @since 3.0 */
int JavadocInternalTypeNameProvided= Javadoc + Internal + 507;
/** @since 3.0 */
int JavadocInheritedMethodHidesEnclosingName= Javadoc + Internal + 508;
/** @since 3.0 */
int JavadocInheritedFieldHidesEnclosingName= Javadoc + Internal + 509;
/** @since 3.0 */
int JavadocInheritedNameHidesEnclosingTypeName= Javadoc + Internal + 510;
/** @since 3.0 */
int JavadocAmbiguousMethodReference= Javadoc + Internal + 511;
/** @since 3.0 */
int JavadocUnterminatedInlineTag= Javadoc + Internal + 512;
/** @since 3.0 */
int JavadocMalformedSeeReference= Javadoc + Internal + 513;
/** @since 3.0 */
int JavadocMessagePrefix= Internal + 514;
/** @since 3.1 */
int JavadocMissingHashCharacter= Javadoc + Internal + 515;
/** @since 3.1 */
int JavadocEmptyReturnTag= Javadoc + Internal + 516;
/** @since 3.1 */
int JavadocInvalidValueReference= Javadoc + Internal + 517;
/** @since 3.1 */
int JavadocUnexpectedText= Javadoc + Internal + 518;
/** @since 3.1 */
int JavadocInvalidParamTagName= Javadoc + Internal + 519;
/**
* Generics
*/
/** @since 3.1 */
int DuplicateTypeVariable= Internal + 520;
/** @since 3.1 */
int IllegalTypeVariableSuperReference= Internal + 521;
/** @since 3.1 */
int NonStaticTypeFromStaticInvocation= Internal + 522;
/** @since 3.1 */
int ObjectCannotBeGeneric= Internal + 523;
/** @since 3.1 */
int NonGenericType= TypeRelated + 524;
/** @since 3.1 */
int IncorrectArityForParameterizedType= TypeRelated + 525;
/** @since 3.1 */
int TypeArgumentMismatch= TypeRelated + 526;
/** @since 3.1 */
int DuplicateMethodErasure= TypeRelated + 527;
/** @since 3.1 */
int ReferenceToForwardTypeVariable= TypeRelated + 528;
/** @since 3.1 */
int BoundMustBeAnInterface= TypeRelated + 529;
/** @since 3.1 */
int UnsafeRawConstructorInvocation= TypeRelated + 530;
/** @since 3.1 */
int UnsafeRawMethodInvocation= TypeRelated + 531;
/** @since 3.1 */
int UnsafeTypeConversion= TypeRelated + 532;
/** @since 3.1 */
int InvalidTypeVariableExceptionType= TypeRelated + 533;
/** @since 3.1 */
int InvalidParameterizedExceptionType= TypeRelated + 534;
/** @since 3.1 */
int IllegalGenericArray= TypeRelated + 535;
/** @since 3.1 */
int UnsafeRawFieldAssignment= TypeRelated + 536;
/** @since 3.1 */
int FinalBoundForTypeVariable= TypeRelated + 537;
/** @since 3.1 */
int UndefinedTypeVariable= Internal + 538;
/** @since 3.1 */
int SuperInterfacesCollide= TypeRelated + 539;
/** @since 3.1 */
int WildcardConstructorInvocation= TypeRelated + 540;
/** @since 3.1 */
int WildcardMethodInvocation= TypeRelated + 541;
/** @since 3.1 */
int WildcardFieldAssignment= TypeRelated + 542;
/** @since 3.1 */
int GenericMethodTypeArgumentMismatch= TypeRelated + 543;
/** @since 3.1 */
int GenericConstructorTypeArgumentMismatch= TypeRelated + 544;
/** @since 3.1 */
int UnsafeGenericCast= TypeRelated + 545;
/** @since 3.1 */
int IllegalInstanceofParameterizedType= Internal + 546;
/** @since 3.1 */
int IllegalInstanceofTypeParameter= Internal + 547;
/** @since 3.1 */
int NonGenericMethod= TypeRelated + 548;
/** @since 3.1 */
int IncorrectArityForParameterizedMethod= TypeRelated + 549;
/** @since 3.1 */
int ParameterizedMethodArgumentTypeMismatch= TypeRelated + 550;
/** @since 3.1 */
int NonGenericConstructor= TypeRelated + 551;
/** @since 3.1 */
int IncorrectArityForParameterizedConstructor= TypeRelated + 552;
/** @since 3.1 */
int ParameterizedConstructorArgumentTypeMismatch= TypeRelated + 553;
/** @since 3.1 */
int TypeArgumentsForRawGenericMethod= TypeRelated + 554;
/** @since 3.1 */
int TypeArgumentsForRawGenericConstructor= TypeRelated + 555;
/** @since 3.1 */
int SuperTypeUsingWildcard= TypeRelated + 556;
/** @since 3.1 */
int GenericTypeCannotExtendThrowable= TypeRelated + 557;
/** @since 3.1 */
int IllegalClassLiteralForTypeVariable= TypeRelated + 558;
/** @since 3.1 */
int UnsafeReturnTypeOverride= MethodRelated + 559;
/** @since 3.1 */
int MethodNameClash= MethodRelated + 560;
/** @since 3.1 */
int RawMemberTypeCannotBeParameterized= TypeRelated + 561;
/** @since 3.1 */
int MissingArgumentsForParameterizedMemberType= TypeRelated + 562;
/** @since 3.1 */
int StaticMemberOfParameterizedType= TypeRelated + 563;
/** @since 3.1 */
int BoundHasConflictingArguments= TypeRelated + 564;
/** @since 3.1 */
int DuplicateParameterizedMethods= MethodRelated + 565;
/** @since 3.1 */
int IllegalQualifiedParameterizedTypeAllocation= TypeRelated + 566;
/** @since 3.1 */
int DuplicateBounds= TypeRelated + 567;
/** @since 3.1 */
int BoundCannotBeArray= TypeRelated + 568;
/** @since 3.1 */
int UnsafeRawGenericConstructorInvocation= TypeRelated + 569;
/** @since 3.1 */
int UnsafeRawGenericMethodInvocation= TypeRelated + 570;
/** @since 3.1 */
int TypeParameterHidingType= TypeRelated + 571;
/** @since 3.2 */
int RawTypeReference= TypeRelated + 572;
/** @since 3.2 */
int NoAdditionalBoundAfterTypeVariable= TypeRelated + 573;
/** @since 3.2 */
int UnsafeGenericArrayForVarargs= MethodRelated + 574;
/** @since 3.2 */
int IllegalAccessFromTypeVariable= TypeRelated + 575;
/** @since 3.3 */
int TypeHidingTypeParameterFromType= TypeRelated + 576;
/** @since 3.3 */
int TypeHidingTypeParameterFromMethod= TypeRelated + 577;
/** @since 3.3 */
int InvalidUsageOfWildcard= Syntax + Internal + 578;
/** @since 3.4 */
int UnusedTypeArgumentsForMethodInvocation= MethodRelated + 579;
/**
* Foreach
*/
/** @since 3.1 */
int IncompatibleTypesInForeach= TypeRelated + 580;
/** @since 3.1 */
int InvalidTypeForCollection= Internal + 581;
/** @since 3.6 */
int InvalidTypeForCollectionTarget14= Internal + 582;
/**
* 1.5 Syntax errors (when source level < 1.5)
*/
/** @since 3.1 */
int InvalidUsageOfTypeParameters= Syntax + Internal + 590;
/** @since 3.1 */
int InvalidUsageOfStaticImports= Syntax + Internal + 591;
/** @since 3.1 */
int InvalidUsageOfForeachStatements= Syntax + Internal + 592;
/** @since 3.1 */
int InvalidUsageOfTypeArguments= Syntax + Internal + 593;
/** @since 3.1 */
int InvalidUsageOfEnumDeclarations= Syntax + Internal + 594;
/** @since 3.1 */
int InvalidUsageOfVarargs= Syntax + Internal + 595;
/** @since 3.1 */
int InvalidUsageOfAnnotations= Syntax + Internal + 596;
/** @since 3.1 */
int InvalidUsageOfAnnotationDeclarations= Syntax + Internal + 597;
/** @since 3.4 */
int InvalidUsageOfTypeParametersForAnnotationDeclaration= Syntax + Internal + 598;
/** @since 3.4 */
int InvalidUsageOfTypeParametersForEnumDeclaration= Syntax + Internal + 599;
/**
* Annotation
*/
/** @since 3.1 */
int IllegalModifierForAnnotationMethod= MethodRelated + 600;
/** @since 3.1 */
int IllegalExtendedDimensions= MethodRelated + 601;
/** @since 3.1 */
int InvalidFileNameForPackageAnnotations= Syntax + Internal + 602;
/** @since 3.1 */
int IllegalModifierForAnnotationType= TypeRelated + 603;
/** @since 3.1 */
int IllegalModifierForAnnotationMemberType= TypeRelated + 604;
/** @since 3.1 */
int InvalidAnnotationMemberType= TypeRelated + 605;
/** @since 3.1 */
int AnnotationCircularitySelfReference= TypeRelated + 606;
/** @since 3.1 */
int AnnotationCircularity= TypeRelated + 607;
/** @since 3.1 */
int DuplicateAnnotation= TypeRelated + 608;
/** @since 3.1 */
int MissingValueForAnnotationMember= TypeRelated + 609;
/** @since 3.1 */
int DuplicateAnnotationMember= Internal + 610;
/** @since 3.1 */
int UndefinedAnnotationMember= MethodRelated + 611;
/** @since 3.1 */
int AnnotationValueMustBeClassLiteral= Internal + 612;
/** @since 3.1 */
int AnnotationValueMustBeConstant= Internal + 613;
/**
* @deprecated - problem is no longer generated (code is legite)
* @since 3.1
*/
int AnnotationFieldNeedConstantInitialization= Internal + 614;
/** @since 3.1 */
int IllegalModifierForAnnotationField= Internal + 615;
/** @since 3.1 */
int AnnotationCannotOverrideMethod= MethodRelated + 616;
/** @since 3.1 */
int AnnotationMembersCannotHaveParameters= Syntax + Internal + 617;
/** @since 3.1 */
int AnnotationMembersCannotHaveTypeParameters= Syntax + Internal + 618;
/** @since 3.1 */
int AnnotationTypeDeclarationCannotHaveSuperclass= Syntax + Internal + 619;
/** @since 3.1 */
int AnnotationTypeDeclarationCannotHaveSuperinterfaces= Syntax + Internal + 620;
/** @since 3.1 */
int DuplicateTargetInTargetAnnotation= Internal + 621;
/** @since 3.1 */
int DisallowedTargetForAnnotation= TypeRelated + 622;
/** @since 3.1 */
int MethodMustOverride= MethodRelated + 623;
/** @since 3.1 */
int AnnotationTypeDeclarationCannotHaveConstructor= Syntax + Internal + 624;
/** @since 3.1 */
int AnnotationValueMustBeAnnotation= Internal + 625;
/** @since 3.1 */
int AnnotationTypeUsedAsSuperInterface= TypeRelated + 626;
/** @since 3.1 */
int MissingOverrideAnnotation= MethodRelated + 627;
/** @since 3.1 */
int FieldMissingDeprecatedAnnotation= Internal + 628;
/** @since 3.1 */
int MethodMissingDeprecatedAnnotation= Internal + 629;
/** @since 3.1 */
int TypeMissingDeprecatedAnnotation= Internal + 630;
/** @since 3.1 */
int UnhandledWarningToken= Internal + 631;
/** @since 3.2 */
int AnnotationValueMustBeArrayInitializer= Internal + 632;
/** @since 3.3 */
int AnnotationValueMustBeAnEnumConstant= Internal + 633;
/** @since 3.3 */
int MethodMustOverrideOrImplement= MethodRelated + 634;
/** @since 3.4 */
int UnusedWarningToken= Internal + 635;
/** @since 3.6 */
int MissingOverrideAnnotationForInterfaceMethodImplementation= MethodRelated + 636;
/**
* More problems in generics
*/
/** @since 3.4 */
int UnusedTypeArgumentsForConstructorInvocation= MethodRelated + 660;
/**
* Corrupted binaries
*/
/** @since 3.1 */
int CorruptedSignature= Internal + 700;
/**
* Corrupted source
*/
/** @since 3.2 */
int InvalidEncoding= Internal + 701;
/** @since 3.2 */
int CannotReadSource= Internal + 702;
/**
* Autoboxing
*/
/** @since 3.1 */
int BoxingConversion= Internal + 720;
/** @since 3.1 */
int UnboxingConversion= Internal + 721;
/**
* Enum
*/
/** @since 3.1 */
int IllegalModifierForEnum= TypeRelated + 750;
/** @since 3.1 */
int IllegalModifierForEnumConstant= FieldRelated + 751;
/**
* @deprecated - problem could not be reported, enums cannot be local takes precedence
* @since 3.1
*/
int IllegalModifierForLocalEnum= TypeRelated + 752;
/** @since 3.1 */
int IllegalModifierForMemberEnum= TypeRelated + 753;
/** @since 3.1 */
int CannotDeclareEnumSpecialMethod= MethodRelated + 754;
/** @since 3.1 */
int IllegalQualifiedEnumConstantLabel= FieldRelated + 755;
/** @since 3.1 */
int CannotExtendEnum= TypeRelated + 756;
/** @since 3.1 */
int CannotInvokeSuperConstructorInEnum= MethodRelated + 757;
/** @since 3.1 */
int EnumAbstractMethodMustBeImplemented= MethodRelated + 758;
/** @since 3.1 */
int EnumSwitchCannotTargetField= FieldRelated + 759;
/** @since 3.1 */
int IllegalModifierForEnumConstructor= MethodRelated + 760;
/** @since 3.1 */
int MissingEnumConstantCase= FieldRelated + 761;
/** @since 3.2 */
// TODO need to fix 3.1.1 contribution (inline this constant on client side)
int EnumStaticFieldInInInitializerContext= FieldRelated + 762;
/** @since 3.4 */
int EnumConstantMustImplementAbstractMethod= MethodRelated + 763;
/** @since 3.5 */
int EnumConstantCannotDefineAbstractMethod= MethodRelated + 764;
/** @since 3.5 */
int AbstractMethodInEnum= MethodRelated + 765;
/**
* Var args
*/
/** @since 3.1 */
int IllegalExtendedDimensionsForVarArgs= Syntax + Internal + 800;
/** @since 3.1 */
int MethodVarargsArgumentNeedCast= MethodRelated + 801;
/** @since 3.1 */
int ConstructorVarargsArgumentNeedCast= ConstructorRelated + 802;
/** @since 3.1 */
int VarargsConflict= MethodRelated + 803;
/**
* Javadoc Generic
*/
/** @since 3.1 */
int JavadocGenericMethodTypeArgumentMismatch= Javadoc + Internal + 850;
/** @since 3.1 */
int JavadocNonGenericMethod= Javadoc + Internal + 851;
/** @since 3.1 */
int JavadocIncorrectArityForParameterizedMethod= Javadoc + Internal + 852;
/** @since 3.1 */
int JavadocParameterizedMethodArgumentTypeMismatch= Javadoc + Internal + 853;
/** @since 3.1 */
int JavadocTypeArgumentsForRawGenericMethod= Javadoc + Internal + 854;
/** @since 3.1 */
int JavadocGenericConstructorTypeArgumentMismatch= Javadoc + Internal + 855;
/** @since 3.1 */
int JavadocNonGenericConstructor= Javadoc + Internal + 856;
/** @since 3.1 */
int JavadocIncorrectArityForParameterizedConstructor= Javadoc + Internal + 857;
/** @since 3.1 */
int JavadocParameterizedConstructorArgumentTypeMismatch= Javadoc + Internal + 858;
/** @since 3.1 */
int JavadocTypeArgumentsForRawGenericConstructor= Javadoc + Internal + 859;
/**
* External problems -- These are problems defined by other plugins
*/
/** @since 3.2 */
int ExternalProblemNotFixable= 900;
// indicates an externally defined problem that has a quick-assist processor
// associated with it
/** @since 3.2 */
int ExternalProblemFixable= 901;
}