X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/compiler/IProblem.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/compiler/IProblem.java index 24cd371..85b68a2 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/compiler/IProblem.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/compiler/IProblem.java @@ -33,31 +33,35 @@ * 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: * * - * 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(); @@ -70,9 +74,11 @@ public interface IProblem { 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(); @@ -82,7 +88,7 @@ public interface IProblem { * @return the file name in which the problem was found */ char[] getOriginatingFileName(); - + /** * Answer the end position of the problem (inclusive), or -1 if unknown. * @@ -114,68 +120,84 @@ public interface IProblem { /** * 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; @@ -183,489 +205,830 @@ public interface IProblem { * 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; }