net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/compiler/IProblem.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *     IBM Corporation - added the following constants
  11  *                                 NonStaticAccessToStaticField
  12  *                                 NonStaticAccessToStaticMethod
  13  *                                 Task
  14  *                                                                 ExpressionShouldBeAVariable
  15  *                                                                 AssignmentHasNoEffect
  16  *     IBM Corporation - added the following constants
  17  *                                                                 TooManySyntheticArgumentSlots
  18  *                                                                 TooManyArrayDimensions
  19  *                                                                 TooManyBytesForStringConstant
  20  *                                                                 TooManyMethods
  21  *                                                                 TooManyFields
  22  *                                                                 NonBlankFinalLocalAssignment
  23  *                                                                 ObjectCannotHaveSuperTypes
  24  *                                                                 MissingSemiColon
  25  *                                                                 InvalidParenthesizedExpression
  26  *                                                                 EnclosingInstanceInConstructorCall
  27  *                                                                 BytecodeExceeds64KLimitForConstructor
  28  *                                                                 IncompatibleReturnTypeForNonInheritedInterfaceMethod
  29  *                                                                 UnusedPrivateMethod
  30  *                                                                 UnusedPrivateConstructor
  31  *                                                                 UnusedPrivateType
  32  *                                                                 UnusedPrivateField
  33  *                                                                 IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
  34  *******************************************************************************/
  35 package net.sourceforge.phpdt.core.compiler;
  36
  37 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReasons;
  38
  39 /**
  40  * Description of a Java problem, as detected by the compiler or some of the
  41  * underlying technology reusing the compiler. A problem provides access to:
  42  * <ul>
  43  * <li> its location (originating source file name, source position, line
  44  * number), </li>
  45  * <li> its message description and a predicate to check its severity (warning
  46  * or error). </li>
  47  * <li> its ID : an number identifying the very nature of this problem. All
  48  * possible IDs are listed as constants on this interface. </li>
  49  * </ul>
  50  *
  51  * Note: the compiler produces IProblems internally, which are turned into
  52  * markers by the JavaBuilder so as to persist problem descriptions. This
  53  * explains why there is no API allowing to reach IProblem detected when
  54  * compiling. However, the Java problem markers carry equivalent information to
  55  * IProblem, in particular their ID (attribute "id") is set to one of the IDs
  56  * defined on this interface.
  57  *
  58  * @since 2.0
  59  */
  60 public interface IProblem {
  61
  62         /**
  63          * Answer back the original arguments recorded into the problem.
  64          *
  65          * @return the original arguments recorded into the problem
  66          */
  67         String[] getArguments();
  68
  69         /**
  70          * Returns the problem id
  71          *
  72          * @return the problem id
  73          */
  74         int getID();
  75
  76         /**
  77          * Answer a localized, human-readable message string which describes the
  78          * problem.
  79          *
  80          * @return a localized, human-readable message string which describes the
  81          *         problem
  82          */
  83         String getMessage();
  84
  85         /**
  86          * Answer the file name in which the problem was found.
  87          *
  88          * @return the file name in which the problem was found
  89          */
  90         char[] getOriginatingFileName();
  91
  92         /**
  93          * Answer the end position of the problem (inclusive), or -1 if unknown.
  94          *
  95          * @return the end position of the problem (inclusive), or -1 if unknown
  96          */
  97         int getSourceEnd();
  98
  99         /**
 100          * Answer the line number in source where the problem begins.
 101          *
 102          * @return the line number in source where the problem begins
 103          */
 104         int getSourceLineNumber();
 105
 106         /**
 107          * Answer the start position of the problem (inclusive), or -1 if unknown.
 108          *
 109          * @return the start position of the problem (inclusive), or -1 if unknown
 110          */
 111         int getSourceStart();
 112
 113         /**
 114          * Checks the severity to see if the Error bit is set.
 115          *
 116          * @return true if the Error bit is set for the severity, false otherwise
 117          */
 118         boolean isError();
 119
 120         /**
 121          * Checks the severity to see if the Error bit is not set.
 122          *
 123          * @return true if the Error bit is not set for the severity, false
 124          *         otherwise
 125          */
 126         boolean isWarning();
 127
 128         /**
 129          * Set the end position of the problem (inclusive), or -1 if unknown. Used
 130          * for shifting problem positions.
 131          *
 132          * @param sourceEnd
 133          *            the given end position
 134          */
 135         void setSourceEnd(int sourceEnd);
 136
 137         /**
 138          * Set the line number in source where the problem begins.
 139          *
 140          * @param lineNumber
 141          *            the given line number
 142          */
 143         void setSourceLineNumber(int lineNumber);
 144
 145         /**
 146          * Set the start position of the problem (inclusive), or -1 if unknown. Used
 147          * for shifting problem positions.
 148          *
 149          * @param the
 150          *            given start position
 151          */
 152         void setSourceStart(int sourceStart);
 153
 154         /**
 155          * Problem Categories The high bits of a problem ID contains information
 156          * about the category of a problem. For example, (problemID & TypeRelated) !=
 157          * 0, indicates that this problem is type related.
 158          *
 159          * A problem category can help to implement custom problem filters. Indeed,
 160          * when numerous problems are listed, focusing on import related problems
 161          * first might be relevant.
 162          *
 163          * When a problem is tagged as Internal, it means that no change other than
 164          * a local source code change can fix the corresponding problem.
 165          */
 166         int TypeRelated = 0x01000000;
 167
 168         int FieldRelated = 0x02000000;
 169
 170         int MethodRelated = 0x04000000;
 171
 172         int ConstructorRelated = 0x08000000;
 173
 174         int ImportRelated = 0x10000000;
 175
 176         int Internal = 0x20000000;
 177
 178         int Syntax = 0x40000000;
 179
 180         /**
 181          * @since 3.0
 182          */
 183         int Javadoc = 0x80000000;
 184
 185         /**
 186          * Mask to use in order to filter out the category portion of the problem
 187          * ID.
 188          */
 189         int IgnoreCategoriesMask = 0xFFFFFF;
 190
 191         /**
 192          * Below are listed all available problem IDs. Note that this list could be
 193          * augmented in the future, as new features are added to the Java core
 194          * implementation.
 195          */
 196
 197         /**
 198          * ID reserved for referencing an internal error inside the JavaCore
 199          * implementation which may be surfaced as a problem associated with the
 200          * compilation unit which caused it to occur.
 201          */
 202         int Unclassified = 0;
 203
 204         /**
 205          * Generic type related problems
 206          */
 207         int ObjectHasNoSuperclass = TypeRelated + 1;
 208
 209         int UndefinedType = TypeRelated + 2;
 210
 211         int NotVisibleType = TypeRelated + 3;
 212
 213         int AmbiguousType = TypeRelated + 4;
 214
 215         int UsingDeprecatedType = TypeRelated + 5;
 216
 217         int InternalTypeNameProvided = TypeRelated + 6;
 218
 219         /** @since 2.1 */
 220         int UnusedPrivateType = Internal + TypeRelated + 7;
 221
 222         int IncompatibleTypesInEqualityOperator = TypeRelated + 15;
 223
 224         int IncompatibleTypesInConditionalOperator = TypeRelated + 16;
 225
 226         int TypeMismatch = TypeRelated + 17;
 227
 228         /**
 229          * Inner types related problems
 230          */
 231         int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
 232
 233         int MissingEnclosingInstance = TypeRelated + 21;
 234
 235         int IncorrectEnclosingInstanceReference = TypeRelated + 22;
 236
 237         int IllegalEnclosingInstanceSpecification = TypeRelated + 23;
 238
 239         int CannotDefineStaticInitializerInLocalType = Internal + 24;
 240
 241         int OuterLocalMustBeFinal = Internal + 25;
 242
 243         int CannotDefineInterfaceInLocalType = Internal + 26;
 244
 245         int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27;
 246
 247         /** @since 2.1 */
 248         int EnclosingInstanceInConstructorCall = Internal + 28;
 249
 250         int AnonymousClassCannotExtendFinalClass = TypeRelated + 29;
 251
 252         // variables
 253         int UndefinedName = 50;
 254
 255         int UninitializedLocalVariable = Internal + 51;
 256
 257         int VariableTypeCannotBeVoid = Internal + 52;
 258
 259         int VariableTypeCannotBeVoidArray = Internal + 53;
 260
 261         int CannotAllocateVoidArray = Internal + 54;
 262
 263         // local variables
 264         int RedefinedLocal = Internal + 55;
 265
 266         int RedefinedArgument = Internal + 56;
 267
 268         // final local variables
 269         int DuplicateFinalLocalInitialization = Internal + 57;
 270
 271         /** @since 2.1 */
 272         int NonBlankFinalLocalAssignment = Internal + 58;
 273
 274         int FinalOuterLocalAssignment = Internal + 60;
 275
 276         int LocalVariableIsNeverUsed = Internal + 61;
 277
 278         int ArgumentIsNeverUsed = Internal + 62;
 279
 280         int BytecodeExceeds64KLimit = Internal + 63;
 281
 282         int BytecodeExceeds64KLimitForClinit = Internal + 64;
 283
 284         int TooManyArgumentSlots = Internal + 65;
 285
 286         int TooManyLocalVariableSlots = Internal + 66;
 287
 288         /** @since 2.1 */
 289         int TooManySyntheticArgumentSlots = Internal + 67;
 290
 291         /** @since 2.1 */
 292         int TooManyArrayDimensions = Internal + 68;
 293
 294         /** @since 2.1 */
 295         int BytecodeExceeds64KLimitForConstructor = Internal + 69;
 296
 297         // fields
 298         int UndefinedField = FieldRelated + 70;
 299
 300         int NotVisibleField = FieldRelated + 71;
 301
 302         int AmbiguousField = FieldRelated + 72;
 303
 304         int UsingDeprecatedField = FieldRelated + 73;
 305
 306         int NonStaticFieldFromStaticInvocation = FieldRelated + 74;
 307
 308         int ReferenceToForwardField = FieldRelated + Internal + 75;
 309
 310         /** @since 2.1 */
 311         int NonStaticAccessToStaticField = Internal + FieldRelated + 76;
 312
 313         /** @since 2.1 */
 314         int UnusedPrivateField = Internal + FieldRelated + 77;
 315
 316         // blank final fields
 317         int FinalFieldAssignment = FieldRelated + 80;
 318
 319         int UninitializedBlankFinalField = FieldRelated + 81;
 320
 321         int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
 322
 323         // methods
 324         int UndefinedMethod = MethodRelated + 100;
 325
 326         int NotVisibleMethod = MethodRelated + 101;
 327
 328         int AmbiguousMethod = MethodRelated + 102;
 329
 330         int UsingDeprecatedMethod = MethodRelated + 103;
 331
 332         int DirectInvocationOfAbstractMethod = MethodRelated + 104;
 333
 334         int VoidMethodReturnsValue = MethodRelated + 105;
 335
 336         int MethodReturnsVoid = MethodRelated + 106;
 337
 338         int MethodRequiresBody = Internal + MethodRelated + 107;
 339
 340         int ShouldReturnValue = Internal + MethodRelated + 108;
 341
 342         int MethodButWithConstructorName = MethodRelated + 110;
 343
 344         int MissingReturnType = TypeRelated + 111;
 345
 346         int BodyForNativeMethod = Internal + MethodRelated + 112;
 347
 348         int BodyForAbstractMethod = Internal + MethodRelated + 113;
 349
 350         int NoMessageSendOnBaseType = MethodRelated + 114;
 351
 352         int ParameterMismatch = MethodRelated + 115;
 353
 354         int NoMessageSendOnArrayType = MethodRelated + 116;
 355
 356         /** @since 2.1 */
 357         int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117;
 358
 359         /** @since 2.1 */
 360         int UnusedPrivateMethod = Internal + MethodRelated + 118;
 361
 362         // constructors
 363         int UndefinedConstructor = ConstructorRelated + 130;
 364
 365         int NotVisibleConstructor = ConstructorRelated + 131;
 366
 367         int AmbiguousConstructor = ConstructorRelated + 132;
 368
 369         int UsingDeprecatedConstructor = ConstructorRelated + 133;
 370
 371         /** @since 2.1 */
 372         int UnusedPrivateConstructor = Internal + MethodRelated + 134;
 373
 374         // explicit constructor calls
 375         int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135;
 376
 377         int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136;
 378
 379         int RecursiveConstructorInvocation = ConstructorRelated + 137;
 380
 381         int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138;
 382
 383         // implicit constructor calls
 384         int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140;
 385
 386         int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141;
 387
 388         int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142;
 389
 390         int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143;
 391
 392         int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144;
 393
 394         int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145;
 395
 396         int UnhandledExceptionInDefaultConstructor = TypeRelated + 146;
 397
 398         int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147;
 399
 400         // expressions
 401         int ArrayReferenceRequired = Internal + 150;
 402
 403         int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
 404
 405         // constant expressions
 406         int StringConstantIsExceedingUtf8Limit = Internal + 152;
 407
 408         int NonConstantExpression = 153;
 409
 410         int NumericValueOutOfRange = Internal + 154;
 411
 412         // cast expressions
 413         int IllegalCast = TypeRelated + 156;
 414
 415         // allocations
 416         int InvalidClassInstantiation = TypeRelated + 157;
 417
 418         int CannotDefineDimensionExpressionsWithInit = Internal + 158;
 419
 420         int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159;
 421
 422         // operators
 423         int InvalidOperator = Internal + 160;
 424
 425         // statements
 426         int CodeCannotBeReached = Internal + 161;
 427
 428         int CannotReturnInInitializer = Internal + 162;
 429
 430         int InitializerMustCompleteNormally = Internal + 163;
 431
 432         // assert
 433         int InvalidVoidExpression = Internal + 164;
 434
 435         // try
 436         int MaskedCatch = TypeRelated + 165;
 437
 438         int DuplicateDefaultCase = 166;
 439
 440         int UnreachableCatch = TypeRelated + MethodRelated + 167;
 441
 442         int UnhandledException = TypeRelated + 168;
 443
 444         // switch
 445         int IncorrectSwitchType = TypeRelated + 169;
 446
 447         int DuplicateCase = FieldRelated + 170;
 448
 449         // labelled
 450         int DuplicateLabel = Internal + 171;
 451
 452         int InvalidBreak = Internal + 172;
 453
 454         int InvalidContinue = Internal + 173;
 455
 456         int UndefinedLabel = Internal + 174;
 457
 458         // synchronized
 459         int InvalidTypeToSynchronized = Internal + 175;
 460
 461         int InvalidNullToSynchronized = Internal + 176;
 462
 463         // throw
 464         int CannotThrowNull = Internal + 177;
 465
 466         // assignment
 467         /** @since 2.1 */
 468         int AssignmentHasNoEffect = Internal + 178;
 469
 470         // inner emulation
 471         int NeedToEmulateFieldReadAccess = FieldRelated + 190;
 472
 473         int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
 474
 475         int NeedToEmulateMethodAccess = MethodRelated + 192;
 476
 477         int NeedToEmulateConstructorAccess = MethodRelated + 193;
 478
 479         // inherited name hides enclosing name (sort of ambiguous)
 480         int InheritedMethodHidesEnclosingName = MethodRelated + 195;
 481
 482         int InheritedFieldHidesEnclosingName = FieldRelated + 196;
 483
 484         int InheritedTypeHidesEnclosingName = TypeRelated + 197;
 485
 486         // miscellaneous
 487         int ThisInStaticContext = Internal + 200;
 488
 489         int StaticMethodRequested = Internal + MethodRelated + 201;
 490
 491         int IllegalDimension = Internal + 202;
 492
 493         int InvalidTypeExpression = Internal + 203;
 494
 495         int ParsingError = Syntax + Internal + 204;
 496
 497         int ParsingErrorNoSuggestion = Syntax + Internal + 205;
 498
 499         int InvalidUnaryExpression = Syntax + Internal + 206;
 500
 501         // syntax errors
 502         int InterfaceCannotHaveConstructors = Syntax + Internal + 207;
 503
 504         int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208;
 505
 506         int ParsingErrorOnKeyword = Syntax + Internal + 209;
 507
 508         int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;
 509
 510         int PHPParsingError = Syntax + Internal + 211;
 511
 512         int PHPParsingWarning = Syntax + Internal + 212;
 513
 514         int PHPVarDeprecatedWarning = Syntax + Internal + 213;
 515
 516         int PHPBadStyleKeywordWarning = Syntax + Internal + 214;
 517
 518         int PHPBadStyleUppercaseIdentifierWarning = Syntax + Internal + 215;
 519
 520         int PHPIncludeNotExistWarning = Syntax + Internal + 216;
 521
 522         int UnmatchedBracket = Syntax + Internal + 220;
 523
 524         int NoFieldOnBaseType = FieldRelated + 221;
 525
 526         int InvalidExpressionAsStatement = Syntax + Internal + 222;
 527
 528         /** @since 2.1 */
 529         int ExpressionShouldBeAVariable = Syntax + Internal + 223;
 530
 531         /** @since 2.1 */
 532         int MissingSemiColon = Syntax + Internal + 224;
 533
 534         /** @since 2.1 */
 535         int InvalidParenthesizedExpression = Syntax + Internal + 225;
 536
 537         // scanner errors
 538         int EndOfSource = Syntax + Internal + 250;
 539
 540         int InvalidHexa = Syntax + Internal + 251;
 541
 542         int InvalidOctal = Syntax + Internal + 252;
 543
 544         int InvalidCharacterConstant = Syntax + Internal + 253;
 545
 546         int InvalidEscape = Syntax + Internal + 254;
 547
 548         int InvalidInput = Syntax + Internal + 255;
 549
 550         int InvalidUnicodeEscape = Syntax + Internal + 256;
 551
 552         int InvalidFloat = Syntax + Internal + 257;
 553
 554         int NullSourceString = Syntax + Internal + 258;
 555
 556         int UnterminatedString = Syntax + Internal + 259;
 557
 558         int UnterminatedComment = Syntax + Internal + 260;
 559
 560         // type related problems
 561         int InterfaceCannotHaveInitializers = TypeRelated + 300;
 562
 563         int DuplicateModifierForType = TypeRelated + 301;
 564
 565         int IllegalModifierForClass = TypeRelated + 302;
 566
 567         int IllegalModifierForInterface = TypeRelated + 303;
 568
 569         int IllegalModifierForMemberClass = TypeRelated + 304;
 570
 571         int IllegalModifierForMemberInterface = TypeRelated + 305;
 572
 573         int IllegalModifierForLocalClass = TypeRelated + 306;
 574
 575         int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308;
 576
 577         int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309;
 578
 579         int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310;
 580
 581         int IllegalStaticModifierForMemberType = TypeRelated + 311;
 582
 583         int SuperclassMustBeAClass = TypeRelated + 312;
 584
 585         int ClassExtendFinalClass = TypeRelated + 313;
 586
 587         int DuplicateSuperInterface = TypeRelated + 314;
 588
 589         int SuperInterfaceMustBeAnInterface = TypeRelated + 315;
 590
 591         int HierarchyCircularitySelfReference = TypeRelated + 316;
 592
 593         int HierarchyCircularity = TypeRelated + 317;
 594
 595         int HidingEnclosingType = TypeRelated + 318;
 596
 597         int DuplicateNestedType = TypeRelated + 319;
 598
 599         int CannotThrowType = TypeRelated + 320;
 600
 601         int PackageCollidesWithType = TypeRelated + 321;
 602
 603         int TypeCollidesWithPackage = TypeRelated + 322;
 604
 605         int DuplicateTypes = TypeRelated + 323;
 606
 607         int IsClassPathCorrect = TypeRelated + 324;
 608
 609         int PublicClassMustMatchFileName = TypeRelated + 325;
 610
 611         int MustSpecifyPackage = 326;
 612
 613         int HierarchyHasProblems = TypeRelated + 327;
 614
 615         int PackageIsNotExpectedPackage = 328;
 616
 617         /** @since 2.1 */
 618         int ObjectCannotHaveSuperTypes = 329;
 619
 620         // int InvalidSuperclassBase = TypeRelated + 329; // reserved to 334
 621         // included
 622         int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated
 623                                                                                                                                                         // +
 624                                                                                                                                                         // 330
 625
 626         int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated
 627                                                                                                                                                                 // +
 628                                                                                                                                                                 // 331
 629
 630         int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated
 631                                                                                                                                                         // +
 632                                                                                                                                                         // 332
 633
 634         int SuperclassInternalNameProvided = TypeRelated + 329
 635                         + ProblemReasons.InternalNameProvided; // TypeRelated + 333
 636
 637         int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329
 638                         + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated +
 639                                                                                                                                 // 334
 640
 641         // int InvalidInterfaceBase = TypeRelated + 334; // reserved to 339 included
 642         int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated
 643                                                                                                                                                         // +
 644                                                                                                                                                         // 335
 645
 646         int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated
 647                                                                                                                                                                 // +
 648                                                                                                                                                                 // 336
 649
 650         int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated
 651                                                                                                                                                         // +
 652                                                                                                                                                         // 337
 653
 654         int InterfaceInternalNameProvided = TypeRelated + 334
 655                         + ProblemReasons.InternalNameProvided; // TypeRelated + 338
 656
 657         int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334
 658                         + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated +
 659                                                                                                                                 // 339
 660
 661         // field related problems
 662         int DuplicateField = FieldRelated + 340;
 663
 664         int DuplicateModifierForField = FieldRelated + 341;
 665
 666         int IllegalModifierForField = FieldRelated + 342;
 667
 668         int IllegalModifierForInterfaceField = FieldRelated + 343;
 669
 670         int IllegalVisibilityModifierCombinationForField = FieldRelated + 344;
 671
 672         int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345;
 673
 674         int UnexpectedStaticModifierForField = FieldRelated + 346;
 675
 676         // int FieldTypeProblemBase = FieldRelated + 349; //reserved to 354
 677         int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated
 678                                                                                                                                                         // +
 679                                                                                                                                                         // 350
 680
 681         int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated
 682                                                                                                                                                                 // +
 683                                                                                                                                                                 // 351
 684
 685         int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated
 686                                                                                                                                                         // +
 687                                                                                                                                                         // 352
 688
 689         int FieldTypeInternalNameProvided = FieldRelated + 349
 690                         + ProblemReasons.InternalNameProvided; // FieldRelated + 353
 691
 692         int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349
 693                         + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated
 694                                                                                                                                 // + 354
 695
 696         // method related problems
 697         int DuplicateMethod = MethodRelated + 355;
 698
 699         int IllegalModifierForArgument = MethodRelated + 356;
 700
 701         int DuplicateModifierForMethod = MethodRelated + 357;
 702
 703         int IllegalModifierForMethod = MethodRelated + 358;
 704
 705         int IllegalModifierForInterfaceMethod = MethodRelated + 359;
 706
 707         int IllegalVisibilityModifierCombinationForMethod = MethodRelated + 360;
 708
 709         int UnexpectedStaticModifierForMethod = MethodRelated + 361;
 710
 711         int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
 712
 713         int AbstractMethodInAbstractClass = MethodRelated + 363;
 714
 715         int ArgumentTypeCannotBeVoid = MethodRelated + 364;
 716
 717         int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
 718
 719         int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
 720
 721         int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
 722
 723         int DuplicateModifierForArgument = MethodRelated + 368;
 724
 725         // int ArgumentProblemBase = MethodRelated + 369; // reserved to 374
 726         // included.
 727         int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated
 728                                                                                                                                                                 // +
 729                                                                                                                                                                 // 370
 730
 731         int ArgumentTypeNotVisible = MethodRelated + 369
 732                         + ProblemReasons.NotVisible; // MethodRelated + 371
 733
 734         int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated
 735                                                                                                                                                                 // +
 736                                                                                                                                                                 // 372
 737
 738         int ArgumentTypeInternalNameProvided = MethodRelated + 369
 739                         + ProblemReasons.InternalNameProvided; // MethodRelated + 373
 740
 741         int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369
 742                         + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated
 743                                                                                                                                 // + 374
 744
 745         // int ExceptionTypeProblemBase = MethodRelated + 374; // reserved to 379
 746         // included.
 747         int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated
 748                                                                                                                                                                 // +
 749                                                                                                                                                                 // 375
 750
 751         int ExceptionTypeNotVisible = MethodRelated + 374
 752                         + ProblemReasons.NotVisible; // MethodRelated + 376
 753
 754         int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated
 755                                                                                                                                                                         // +
 756                                                                                                                                                                         // 377
 757
 758         int ExceptionTypeInternalNameProvided = MethodRelated + 374
 759                         + ProblemReasons.InternalNameProvided; // MethodRelated + 378
 760
 761         int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374
 762                         + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated
 763                                                                                                                                 // + 379
 764
 765         // int ReturnTypeProblemBase = MethodRelated + 379;
 766         int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated
 767                                                                                                                                                         // +
 768                                                                                                                                                         // 380
 769
 770         int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated
 771                                                                                                                                                                 // +
 772                                                                                                                                                                 // 381
 773
 774         int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated
 775                                                                                                                                                                 // +
 776                                                                                                                                                                 // 382
 777
 778         int ReturnTypeInternalNameProvided = MethodRelated + 379
 779                         + ProblemReasons.InternalNameProvided; // MethodRelated + 383
 780
 781         int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379
 782                         + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated
 783                                                                                                                                 // + 384
 784
 785         // import related problems
 786         int ConflictingImport = ImportRelated + 385;
 787
 788         int DuplicateImport = ImportRelated + 386;
 789
 790         int CannotImportPackage = ImportRelated + 387;
 791
 792         int UnusedImport = ImportRelated + 388;
 793
 794         // int ImportProblemBase = ImportRelated + 389;
 795         int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated
 796                                                                                                                                                 // + 390
 797
 798         int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated
 799                                                                                                                                                         // +
 800                                                                                                                                                         // 391
 801
 802         int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated
 803                                                                                                                                                         // +
 804                                                                                                                                                         // 392
 805
 806         int ImportInternalNameProvided = ImportRelated + 389
 807                         + ProblemReasons.InternalNameProvided; // ImportRelated + 393
 808
 809         int ImportInheritedNameHidesEnclosingName = ImportRelated + 389
 810                         + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated
 811                                                                                                                                 // + 394
 812
 813         // local variable related problems
 814         int DuplicateModifierForVariable = MethodRelated + 395;
 815
 816         int IllegalModifierForVariable = MethodRelated + 396;
 817
 818         // method verifier problems
 819         int AbstractMethodMustBeImplemented = MethodRelated + 400;
 820
 821         int FinalMethodCannotBeOverridden = MethodRelated + 401;
 822
 823         int IncompatibleExceptionInThrowsClause = MethodRelated + 402;
 824
 825         int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403;
 826
 827         int IncompatibleReturnType = MethodRelated + 404;
 828
 829         int InheritedMethodReducesVisibility = MethodRelated + 405;
 830
 831         int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406;
 832
 833         int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407;
 834
 835         int StaticInheritedMethodConflicts = MethodRelated + 408;
 836
 837         int MethodReducesVisibility = MethodRelated + 409;
 838
 839         int OverridingNonVisibleMethod = MethodRelated + 410;
 840
 841         int AbstractMethodCannotBeOverridden = MethodRelated + 411;
 842
 843         int OverridingDeprecatedMethod = MethodRelated + 412;
 844
 845         /** @since 2.1 */
 846         int IncompatibleReturnTypeForNonInheritedInterfaceMethod = MethodRelated + 413;
 847
 848         /** @since 2.1 */
 849         int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod = MethodRelated + 414;
 850
 851         // code snippet support
 852         int CodeSnippetMissingClass = Internal + 420;
 853
 854         int CodeSnippetMissingMethod = Internal + 421;
 855
 856         int NonExternalizedStringLiteral = Internal + 261;
 857
 858         int CannotUseSuperInCodeSnippet = Internal + 422;
 859
 860         // constant pool
 861         int TooManyConstantsInConstantPool = Internal + 430;
 862
 863         /** @since 2.1 */
 864         int TooManyBytesForStringConstant = Internal + 431;
 865
 866         // static constraints
 867         /** @since 2.1 */
 868         int TooManyFields = Internal + 432;
 869
 870         /** @since 2.1 */
 871         int TooManyMethods = Internal + 433;
 872
 873         // 1.4 features
 874         // assertion warning
 875         int UseAssertAsAnIdentifier = Internal + 440;
 876
 877         // detected task
 878         /** @since 2.1 */
 879         int Task = Internal + 450;
 880
 881         // block
 882         /** @since 3.0 */
 883         int UndocumentedEmptyBlock = Internal + 460;
 884
 885         /*
 886          * Javadoc comments
 887          */
 888         /** @since 3.0 */
 889         int JavadocUnexpectedTag = Javadoc + Internal + 470;
 890
 891         /** @since 3.0 */
 892         int JavadocMissingParamTag = Javadoc + Internal + 471;
 893
 894         /** @since 3.0 */
 895         int JavadocMissingParamName = Javadoc + Internal + 472;
 896
 897         /** @since 3.0 */
 898         int JavadocDuplicateParamName = Javadoc + Internal + 473;
 899
 900         /** @since 3.0 */
 901         int JavadocInvalidParamName = Javadoc + Internal + 474;
 902
 903         /** @since 3.0 */
 904         int JavadocMissingReturnTag = Javadoc + Internal + 475;
 905
 906         /** @since 3.0 */
 907         int JavadocDuplicateReturnTag = Javadoc + Internal + 476;
 908
 909         /** @since 3.0 */
 910         int JavadocMissingThrowsTag = Javadoc + Internal + 477;
 911
 912         /** @since 3.0 */
 913         int JavadocMissingThrowsClassName = Javadoc + Internal + 478;
 914
 915         /** @since 3.0 */
 916         int JavadocInvalidThrowsClass = Javadoc + Internal + 479;
 917
 918         /** @since 3.0 */
 919         int JavadocDuplicateThrowsClassName = Javadoc + Internal + 480;
 920
 921         /** @since 3.0 */
 922         int JavadocInvalidThrowsClassName = Javadoc + Internal + 481;
 923
 924         /** @since 3.0 */
 925         int JavadocMissingSeeReference = Javadoc + Internal + 482;
 926
 927         /** @since 3.0 */
 928         int JavadocInvalidSeeReference = Javadoc + Internal + 483;
 929
 930         /** @since 3.0 */
 931         int JavadocInvalidSeeHref = Javadoc + Internal + 484;
 932
 933         /** @since 3.0 */
 934         int JavadocInvalidSeeArgs = Javadoc + Internal + 485;
 935
 936         /** @since 3.0 */
 937         int JavadocMissing = Javadoc + Internal + 486;
 938
 939         /** @since 3.0 */
 940         int JavadocInvalidTag = Javadoc + Internal + 487;
 941
 942         /*
 943          * ID for field errors in Javadoc
 944          */
 945         /** @since 3.0 */
 946         int JavadocUndefinedField = Javadoc + Internal + 488;
 947
 948         /** @since 3.0 */
 949         int JavadocNotVisibleField = Javadoc + Internal + 489;
 950
 951         /** @since 3.0 */
 952         int JavadocAmbiguousField = Javadoc + Internal + 490;
 953
 954         /** @since 3.0 */
 955         int JavadocUsingDeprecatedField = Javadoc + Internal + 491;
 956
 957         /*
 958          * IDs for constructor errors in Javadoc
 959          */
 960         /** @since 3.0 */
 961         int JavadocUndefinedConstructor = Javadoc + Internal + 492;
 962
 963         /** @since 3.0 */
 964         int JavadocNotVisibleConstructor = Javadoc + Internal + 493;
 965
 966         /** @since 3.0 */
 967         int JavadocAmbiguousConstructor = Javadoc + Internal + 494;
 968
 969         /** @since 3.0 */
 970         int JavadocUsingDeprecatedConstructor = Javadoc + Internal + 495;
 971
 972         /*
 973          * IDs for method errors in Javadoc
 974          */
 975         /** @since 3.0 */
 976         int JavadocUndefinedMethod = Javadoc + Internal + 496;
 977
 978         /** @since 3.0 */
 979         int JavadocNotVisibleMethod = Javadoc + Internal + 497;
 980
 981         /** @since 3.0 */
 982         int JavadocAmbiguousMethod = Javadoc + Internal + 498;
 983
 984         /** @since 3.0 */
 985         int JavadocUsingDeprecatedMethod = Javadoc + Internal + 499;
 986
 987         /** @since 3.0 */
 988         int JavadocNoMessageSendOnBaseType = Javadoc + Internal + 500;
 989
 990         /** @since 3.0 */
 991         int JavadocParameterMismatch = Javadoc + Internal + 501;
 992
 993         /** @since 3.0 */
 994         int JavadocNoMessageSendOnArrayType = Javadoc + Internal + 502;
 995
 996         /*
 997          * IDs for type errors in Javadoc
 998          */
 999         /** @since 3.0 */
1000         int JavadocUndefinedType = Javadoc + Internal + 503;
1001
1002         /** @since 3.0 */
1003         int JavadocNotVisibleType = Javadoc + Internal + 504;
1004
1005         /** @since 3.0 */
1006         int JavadocAmbiguousType = Javadoc + Internal + 505;
1007
1008         /** @since 3.0 */
1009         int JavadocUsingDeprecatedType = Javadoc + Internal + 506;
1010
1011         /** @since 3.0 */
1012         int JavadocInternalTypeNameProvided = Javadoc + Internal + 507;
1013
1014         /** @since 3.0 */
1015         int JavadocInheritedMethodHidesEnclosingName = Javadoc + Internal + 508;
1016
1017         /** @since 3.0 */
1018         int JavadocInheritedFieldHidesEnclosingName = Javadoc + Internal + 509;
1019
1020         /** @since 3.0 */
1021         int JavadocInheritedNameHidesEnclosingTypeName = Javadoc + Internal + 510;
1022
1023         /** @since 3.0 */
1024         int JavadocAmbiguousMethodReference = Javadoc + Internal + 511;
1025
1026         /** @since 3.0 */
1027         int JavadocUnterminatedInlineTag = Javadoc + Internal + 512;
1028
1029         /** @since 3.0 */
1030         int JavadocMalformedSeeReference = Javadoc + Internal + 513;
1031
1032         /** @since 3.0 */
1033         int JavadocMessagePrefix = Internal + 515;
1034 }