* IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
*******************************************************************************/
package net.sourceforge.phpdt.core.compiler;
-
+
import net.sourceforge.phpdt.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:
+ * 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 : an number identifying the very nature of this problem. All possible IDs are listed
- * as constants on this interface. </li>
+ * <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 : an 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.
+ * 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
*/
-public interface IProblem {
-
+public interface IProblem {
+
/**
* Answer back the original arguments recorded into the problem.
+ *
* @return the original arguments recorded into the problem
*/
String[] getArguments();
int getID();
/**
- * Answer a localized, human-readable message string which describes the problem.
+ * Answer a localized, human-readable message string which describes the
+ * problem.
*
- * @return a localized, human-readable message string which describes the problem
+ * @return a localized, human-readable message string which describes the
+ * problem
*/
String getMessage();
* @return the file name in which the problem was found
*/
char[] getOriginatingFileName();
-
+
/**
* Answer the end position of the problem (inclusive), or -1 if unknown.
*
/**
* 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
+ * @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.
+ * Set the end position of the problem (inclusive), or -1 if unknown. Used
+ * for shifting problem positions.
*
- * @param sourceEnd the given end position
+ * @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
+ * @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.
+ * Set the start position of the problem (inclusive), or -1 if unknown. Used
+ * for shifting problem positions.
*
- * @param the given start position
+ * @param 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.
+ * 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.
+ * 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.
+ * When a problem is tagged as Internal, it means that no change other than
+ * a local source code change can fix the corresponding problem.
*/
int TypeRelated = 0x01000000;
+
int FieldRelated = 0x02000000;
+
int MethodRelated = 0x04000000;
+
int ConstructorRelated = 0x08000000;
+
int ImportRelated = 0x10000000;
+
int Internal = 0x20000000;
- int Syntax = 0x40000000;
+
+ int Syntax = 0x40000000;
+
/**
* @since 3.0
*/
int Javadoc = 0x80000000;
+
/**
- * Mask to use in order to filter out the category portion of the problem ID.
+ * 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.
+ * 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.
+ * 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;
* Generic 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;
/**
* Inner types related problems
*/
int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
+
int MissingEnclosingInstance = TypeRelated + 21;
+
int IncorrectEnclosingInstanceReference = TypeRelated + 22;
- int IllegalEnclosingInstanceSpecification = TypeRelated + 23;
+
+ 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;
// variables
int UndefinedName = 50;
+
int UninitializedLocalVariable = Internal + 51;
+
int VariableTypeCannotBeVoid = Internal + 52;
+
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;
+
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;
-
+
// blank final fields
int FinalFieldAssignment = FieldRelated + 80;
+
int UninitializedBlankFinalField = FieldRelated + 81;
+
int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
// 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;
+ int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117;
+
/** @since 2.1 */
int UnusedPrivateMethod = Internal + MethodRelated + 118;
-
+
// constructors
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;
+
// 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
int ArrayReferenceRequired = Internal + 150;
+
int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
+
// constant expressions
int StringConstantIsExceedingUtf8Limit = Internal + 152;
+
int NonConstantExpression = 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 = 166;
+
int UnreachableCatch = TypeRelated + MethodRelated + 167;
+
int UnhandledException = TypeRelated + 168;
- // switch
+
+ // 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
+
+ // synchronized
int InvalidTypeToSynchronized = Internal + 175;
+
int InvalidNullToSynchronized = Internal + 176;
+
// throw
int CannotThrowNull = Internal + 177;
+
// assignment
/** @since 2.1 */
int AssignmentHasNoEffect = Internal + 178;
-
+
// inner emulation
int NeedToEmulateFieldReadAccess = FieldRelated + 190;
+
int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
+
int NeedToEmulateMethodAccess = MethodRelated + 192;
+
int NeedToEmulateConstructorAccess = MethodRelated + 193;
- //inherited name hides enclosing name (sort of ambiguous)
+ // inherited name hides enclosing name (sort of ambiguous)
int InheritedMethodHidesEnclosingName = MethodRelated + 195;
+
int InheritedFieldHidesEnclosingName = FieldRelated + 196;
+
int InheritedTypeHidesEnclosingName = TypeRelated + 197;
// miscellaneous
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 ParsingErrorOnKeyword = Syntax + Internal + 209;
+
int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;
+
int PHPParsingError = Syntax + Internal + 211;
+
int PHPParsingWarning = Syntax + Internal + 212;
+
int PHPVarDeprecatedWarning = Syntax + Internal + 213;
+
int PHPBadStyleKeywordWarning = Syntax + Internal + 214;
+
int PHPBadStyleUppercaseIdentifierWarning = Syntax + Internal + 215;
+
int PHPIncludeNotExistWarning = Syntax + Internal + 216;
-
+
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;
-
+
// 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;
// type related problems
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;
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 = 326;
+
int HierarchyHasProblems = TypeRelated + 327;
+
int PackageIsNotExpectedPackage = 328;
+
/** @since 2.1 */
int ObjectCannotHaveSuperTypes = 329;
- // int InvalidSuperclassBase = TypeRelated + 329; // reserved to 334 included
- int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
- int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
- int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
- int SuperclassInternalNameProvided = TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
- int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
+ // int InvalidSuperclassBase = TypeRelated + 329; // reserved to 334
+ // included
+ int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated
+ // +
+ // 330
+
+ int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated
+ // +
+ // 331
+
+ int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated
+ // +
+ // 332
+
+ int SuperclassInternalNameProvided = TypeRelated + 329
+ + ProblemReasons.InternalNameProvided; // TypeRelated + 333
+
+ int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329
+ + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated +
+ // 334
// int InvalidInterfaceBase = TypeRelated + 334; // reserved to 339 included
- int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
- int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
- int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
- int InterfaceInternalNameProvided = TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
- int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
+ int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated
+ // +
+ // 335
+
+ int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated
+ // +
+ // 336
+
+ int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated
+ // +
+ // 337
+
+ int InterfaceInternalNameProvided = TypeRelated + 334
+ + ProblemReasons.InternalNameProvided; // TypeRelated + 338
+
+ 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;
// int FieldTypeProblemBase = FieldRelated + 349; //reserved to 354
- int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350
- int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351
- int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352
- int FieldTypeInternalNameProvided = FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353
- int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349 + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354
-
+ int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated
+ // +
+ // 350
+
+ int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated
+ // +
+ // 351
+
+ int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated
+ // +
+ // 352
+
+ int FieldTypeInternalNameProvided = FieldRelated + 349
+ + ProblemReasons.InternalNameProvided; // FieldRelated + 353
+
+ 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;
+
int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
+
int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
+
int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
+
int DuplicateModifierForArgument = MethodRelated + 368;
- // int ArgumentProblemBase = MethodRelated + 369; // reserved to 374 included.
- int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
- int ArgumentTypeNotVisible = MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
- int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
- int ArgumentTypeInternalNameProvided = MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
- int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
-
- // int ExceptionTypeProblemBase = MethodRelated + 374; // reserved to 379 included.
- int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
- int ExceptionTypeNotVisible = MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
- int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
- int ExceptionTypeInternalNameProvided = MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
- int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
-
- // int ReturnTypeProblemBase = MethodRelated + 379;
- int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
- int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
- int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
- int ReturnTypeInternalNameProvided = MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
- int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
+ // int ArgumentProblemBase = MethodRelated + 369; // reserved to 374
+ // included.
+ int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated
+ // +
+ // 370
+
+ int ArgumentTypeNotVisible = MethodRelated + 369
+ + ProblemReasons.NotVisible; // MethodRelated + 371
+
+ int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated
+ // +
+ // 372
+
+ int ArgumentTypeInternalNameProvided = MethodRelated + 369
+ + ProblemReasons.InternalNameProvided; // MethodRelated + 373
+
+ int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369
+ + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated
+ // + 374
+
+ // int ExceptionTypeProblemBase = MethodRelated + 374; // reserved to 379
+ // included.
+ int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated
+ // +
+ // 375
+
+ int ExceptionTypeNotVisible = MethodRelated + 374
+ + ProblemReasons.NotVisible; // MethodRelated + 376
+
+ int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated
+ // +
+ // 377
+
+ int ExceptionTypeInternalNameProvided = MethodRelated + 374
+ + ProblemReasons.InternalNameProvided; // MethodRelated + 378
+
+ int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374
+ + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated
+ // + 379
+
+ // int ReturnTypeProblemBase = MethodRelated + 379;
+ int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated
+ // +
+ // 380
+
+ int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated
+ // +
+ // 381
+
+ int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated
+ // +
+ // 382
+
+ int ReturnTypeInternalNameProvided = MethodRelated + 379
+ + ProblemReasons.InternalNameProvided; // MethodRelated + 383
+
+ 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 ImportProblemBase = ImportRelated + 389;
- int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
- int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
- int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
- int ImportInternalNameProvided = ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
- int ImportInheritedNameHidesEnclosingName = ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
+ // int ImportProblemBase = ImportRelated + 389;
+ int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated
+ // + 390
+
+ int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated
+ // +
+ // 391
+
+ int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated
+ // +
+ // 392
+
+ int ImportInternalNameProvided = ImportRelated + 389
+ + ProblemReasons.InternalNameProvided; // ImportRelated + 393
+
+ int ImportInheritedNameHidesEnclosingName = ImportRelated + 389
+ + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated
+ // + 394
-
// local variable related problems
int DuplicateModifierForVariable = MethodRelated + 395;
+
int IllegalModifierForVariable = MethodRelated + 396;
// 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;
-
+
// code snippet support
int CodeSnippetMissingClass = Internal + 420;
+
int CodeSnippetMissingMethod = Internal + 421;
+
int NonExternalizedStringLiteral = Internal + 261;
+
int CannotUseSuperInCodeSnippet = Internal + 422;
-
- //constant pool
+
+ // 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;
-
+ int TooManyMethods = Internal + 433;
+
// 1.4 features
// assertion warning
int UseAssertAsAnIdentifier = Internal + 440;
-
+
// detected task
/** @since 2.1 */
int Task = Internal + 450;
-
-// block
+
+ // block
/** @since 3.0 */
int UndocumentedEmptyBlock = Internal + 460;
-
+
/*
* Javadoc comments
*/
/** @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;
+
/** @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 + 515;
}
git://git.phpeclipse.com / phpeclipse.git / blobdiff