Logo Search packages:      
Sourcecode: ecj version File versions

IProblem.java

/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     IBM Corporation - added the following constants
 *                                                 NonStaticAccessToStaticField
 *                                                 NonStaticAccessToStaticMethod
 *                                                 Task
 *                                                 ExpressionShouldBeAVariable
 *                                                 AssignmentHasNoEffect
 *     IBM Corporation - added the following constants
 *                                                 TooManySyntheticArgumentSlots
 *                                                 TooManyArrayDimensions
 *                                                 TooManyBytesForStringConstant
 *                                                 TooManyMethods
 *                                                 TooManyFields
 *                                                 NonBlankFinalLocalAssignment
 *                                                 ObjectCannotHaveSuperTypes
 *                                                 MissingSemiColon
 *                                                 InvalidParenthesizedExpression
 *                                                 EnclosingInstanceInConstructorCall
 *                                                 BytecodeExceeds64KLimitForConstructor
 *                                                 IncompatibleReturnTypeForNonInheritedInterfaceMethod
 *                                                 UnusedPrivateMethod
 *                                                 UnusedPrivateConstructor
 *                                                 UnusedPrivateType
 *                                                 UnusedPrivateField
 *                                                 IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
 *                                                 InvalidExplicitConstructorCall
 *     IBM Corporation - added the following constants
 *                                                 PossibleAccidentalBooleanAssignment
 *                                                 SuperfluousSemicolon
 *                                                 IndirectAccessToStaticField
 *                                                 IndirectAccessToStaticMethod
 *                                                 IndirectAccessToStaticType
 *                                                 BooleanMethodThrowingException
 *                                                 UnnecessaryCast
 *                                                 UnnecessaryArgumentCast
 *                                                 UnnecessaryInstanceof
 *                                                 FinallyMustCompleteNormally
 *                                                 UnusedMethodDeclaredThrownException
 *                                                 UnusedConstructorDeclaredThrownException
 *                                                 InvalidCatchBlockSequence
 *                                                 UnqualifiedFieldAccess
 *     IBM Corporation - added the following constants
 *                                                 Javadoc
 *                                                 JavadocUnexpectedTag
 *                                                 JavadocMissingParamTag
 *                                                 JavadocMissingParamName
 *                                                 JavadocDuplicateParamName
 *                                                 JavadocInvalidParamName
 *                                                 JavadocMissingReturnTag
 *                                                 JavadocDuplicateReturnTag
 *                                                 JavadocMissingThrowsTag
 *                                                 JavadocMissingThrowsClassName
 *                                                 JavadocInvalidThrowsClass
 *                                                 JavadocDuplicateThrowsClassName
 *                                                 JavadocInvalidThrowsClassName
 *                                                 JavadocMissingSeeReference
 *                                                 JavadocInvalidSeeReference
 *                                                 JavadocInvalidSeeHref
 *                                                 JavadocInvalidSeeArgs
 *                                                 JavadocMissing
 *                                                 JavadocInvalidTag
 *                                                 JavadocMessagePrefix
 *                                                 EmptyControlFlowStatement
 *     IBM Corporation - added the following constants
 *                                                 IllegalUsageOfQualifiedTypeReference
 *                                                 InvalidDigit
 *     IBM Corporation - added the following constants
 *                                                 ParameterAssignment
 *                                                 FallthroughCase
 *******************************************************************************/
package org.eclipse.jdt.core.compiler;
 
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;

/**
 * Description of a Java problem, as detected by the compiler or some of the underlying
 * technology reusing the compiler. 
 * A problem provides access to:
 * <ul>
 * <li> its location (originating source file name, source position, line number), </li>
 * <li> its message description and a predicate to check its severity (warning or error). </li>
 * <li> its ID : a number identifying the very nature of this problem. All possible IDs are listed
 * as constants on this interface. </li>
 * </ul>
 * 
 * Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder
 * so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected
 * when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular
 * their ID (attribute "id") is set to one of the IDs defined on this interface.
 * 
 * @since 2.0
 */
00101 public interface IProblem { 
      
/**
 * Answer back the original arguments recorded into the problem.
 * @return the original arguments recorded into the problem
 */
String[] getArguments();

/**
 * Returns the problem id
 * 
 * @return the problem id
 */
int getID();

/**
 * Answer a localized, human-readable message string which describes the problem.
 * 
 * @return a localized, human-readable message string which describes the problem
 */
String getMessage();

/**
 * Answer the file name in which the problem was found.
 * 
 * @return the file name in which the problem was found
 */
char[] getOriginatingFileName();

/**
 * Answer the end position of the problem (inclusive), or -1 if unknown.
 * 
 * @return the end position of the problem (inclusive), or -1 if unknown
 */
int getSourceEnd();

/**
 * Answer the line number in source where the problem begins.
 * 
 * @return the line number in source where the problem begins
 */
int getSourceLineNumber();

/**
 * Answer the start position of the problem (inclusive), or -1 if unknown.
 * 
 * @return the start position of the problem (inclusive), or -1 if unknown
 */
int getSourceStart();

/**
 * Checks the severity to see if the Error bit is set.
 * 
 * @return true if the Error bit is set for the severity, false otherwise
 */
boolean isError();

/**
 * Checks the severity to see if the Error bit is not set.
 * 
 * @return true if the Error bit is not set for the severity, false otherwise
 */
boolean isWarning();

/**
 * Set the end position of the problem (inclusive), or -1 if unknown.
 * Used for shifting problem positions.
 * 
 * @param sourceEnd the given end position
 */
void setSourceEnd(int sourceEnd);

/**
 * Set the line number in source where the problem begins.
 * 
 * @param lineNumber the given line number
 */
void setSourceLineNumber(int lineNumber);

/**
 * Set the start position of the problem (inclusive), or -1 if unknown.
 * Used for shifting problem positions.
 * 
 * @param sourceStart the given start position
 */
void setSourceStart(int sourceStart);


      /**
       * Problem Categories
       * The high bits of a problem ID contains information about the category of a problem. 
       * For example, (problemID & TypeRelated) != 0, indicates that this problem is type related.
       * 
       * A problem category can help to implement custom problem filters. Indeed, when numerous problems
       * are listed, focusing on import related problems first might be relevant.
       * 
       * When a problem is tagged as Internal, it means that no change other than a local source code change
       * can  fix the corresponding problem. A type related problem could be addressed by changing the type
       * involved in it.
       */
00201       int TypeRelated = 0x01000000;
      int FieldRelated = 0x02000000;
      int MethodRelated = 0x04000000;
      int ConstructorRelated = 0x08000000;
      int ImportRelated = 0x10000000;
      int Internal = 0x20000000;
      int Syntax = 0x40000000;
      /** @since 3.0 */
00209       int Javadoc = 0x80000000;
      
      /**
       * Mask to use in order to filter out the category portion of the problem ID.
       */
00214       int IgnoreCategoriesMask = 0xFFFFFF;

      /**
       * Below are listed all available problem IDs. Note that this list could be augmented in the future, 
       * as new features are added to the Java core implementation.
       */

      /**
       * ID reserved for referencing an internal error inside the JavaCore implementation which
       * may be surfaced as a problem associated with the compilation unit which caused it to occur.
       */
00225       int Unclassified = 0;

      /**
       * General type related problems
       */
00230       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 */
00237       int UnusedPrivateType = Internal + TypeRelated + 7;

      int IncompatibleTypesInEqualityOperator = TypeRelated + 15;
      int IncompatibleTypesInConditionalOperator = TypeRelated + 16;
      int TypeMismatch = TypeRelated + 17;
      /** @since 3.0 */
00243       int IndirectAccessToStaticType = Internal + TypeRelated + 18;
      
      /**
       * Inner types related problems
       */
00248       int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
      int MissingEnclosingInstance = TypeRelated + 21;
      int IncorrectEnclosingInstanceReference = TypeRelated + 22;
      int IllegalEnclosingInstanceSpecification = TypeRelated + 23; 
      int CannotDefineStaticInitializerInLocalType = Internal + 24;
      int OuterLocalMustBeFinal = Internal + 25;
      int CannotDefineInterfaceInLocalType = Internal + 26;
      int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27;
      /** @since 2.1 */
00257       int EnclosingInstanceInConstructorCall = Internal + 28;
      int AnonymousClassCannotExtendFinalClass = TypeRelated + 29;
      /** @since 3.1 */
00260       int CannotDefineAnnotationInLocalType = Internal + 30;
      /** @since 3.1 */
00262       int CannotDefineEnumInLocalType = Internal + 31;
      /** @since 3.1 */
00264       int NonStaticContextForEnumMemberType = Internal + 32;

      // variables
      int UndefinedName = Internal + FieldRelated + 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 */
00278       int NonBlankFinalLocalAssignment = Internal + 58;
      /** @since 3.2 */
00280       int ParameterAssignment = Internal + 59;  
      int FinalOuterLocalAssignment = Internal + 60;
      int LocalVariableIsNeverUsed = Internal + 61;
      int ArgumentIsNeverUsed = Internal + 62;
      int BytecodeExceeds64KLimit = Internal + 63;
      int BytecodeExceeds64KLimitForClinit = Internal + 64;
      int TooManyArgumentSlots = Internal + 65;
      int TooManyLocalVariableSlots = Internal + 66;
      /** @since 2.1 */
00289       int TooManySyntheticArgumentSlots = Internal + 67;
      /** @since 2.1 */
00291       int TooManyArrayDimensions = Internal + 68;
      /** @since 2.1 */
00293       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 */
00303       int NonStaticAccessToStaticField = Internal + FieldRelated + 76;
      /** @since 2.1 */
00305       int UnusedPrivateField = Internal + FieldRelated + 77;
      /** @since 3.0 */
00307       int IndirectAccessToStaticField = Internal + FieldRelated + 78;
      /** @since 3.0 */
00309       int UnqualifiedFieldAccess = Internal + FieldRelated + 79;
      
      // blank final fields
      int FinalFieldAssignment = FieldRelated + 80;
      int UninitializedBlankFinalField = FieldRelated + 81;
      int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;

      // variable hiding
      /** @since 3.0 */
00318       int LocalVariableHidingLocalVariable = Internal + 90;       
      /** @since 3.0 */
00320       int LocalVariableHidingField = Internal + FieldRelated + 91;            
      /** @since 3.0 */
00322       int FieldHidingLocalVariable = Internal + FieldRelated + 92;            
      /** @since 3.0 */
00324       int FieldHidingField = Internal + FieldRelated + 93;        
      /** @since 3.0 */
00326       int ArgumentHidingLocalVariable = Internal + 94;            
      /** @since 3.0 */
00328       int ArgumentHidingField = Internal + 95;        
      /** @since 3.1 */
00330       int MissingSerialVersion = Internal + 96;
      
      // methods
      int UndefinedMethod = MethodRelated + 100;
      int NotVisibleMethod = MethodRelated + 101;
      int AmbiguousMethod = MethodRelated + 102;
      int UsingDeprecatedMethod = MethodRelated + 103;
      int DirectInvocationOfAbstractMethod = MethodRelated + 104;
      int VoidMethodReturnsValue = MethodRelated + 105;
      int MethodReturnsVoid = MethodRelated + 106;
      int MethodRequiresBody = Internal + MethodRelated + 107;
      int ShouldReturnValue = Internal + MethodRelated + 108;
      int MethodButWithConstructorName = MethodRelated + 110;
      int MissingReturnType = TypeRelated + 111;
      int BodyForNativeMethod = Internal + MethodRelated + 112;
      int BodyForAbstractMethod = Internal + MethodRelated + 113;
      int NoMessageSendOnBaseType = MethodRelated + 114;
      int ParameterMismatch = MethodRelated + 115;
      int NoMessageSendOnArrayType = MethodRelated + 116;
      /** @since 2.1 */
00350     int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117;
      /** @since 2.1 */
00352       int UnusedPrivateMethod = Internal + MethodRelated + 118;
      /** @since 3.0 */
00354       int IndirectAccessToStaticMethod = Internal + MethodRelated + 119;

      // constructors
      int UndefinedConstructor = ConstructorRelated + 130;
      int NotVisibleConstructor = ConstructorRelated + 131;
      int AmbiguousConstructor = ConstructorRelated + 132;
      int UsingDeprecatedConstructor = ConstructorRelated + 133;
      /** @since 2.1 */
00362       int UnusedPrivateConstructor = Internal + MethodRelated + 134;
      // explicit constructor calls
      int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135;
      int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136;
      int RecursiveConstructorInvocation = ConstructorRelated + 137;
      int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138;
      /** @since 3.0 */
00369       int InvalidExplicitConstructorCall = ConstructorRelated + Syntax + 139;
      // implicit constructor calls
      int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140;
      int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141;
      int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142;
      int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143;
      int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144;
      int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145;
      int UnhandledExceptionInDefaultConstructor = TypeRelated + 146;
      int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147;
                        
      // expressions
      int ArrayReferenceRequired = Internal + 150;
      int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
      // constant expressions
      int StringConstantIsExceedingUtf8Limit = Internal + 152;
      int NonConstantExpression = Internal + 153;
      int NumericValueOutOfRange = Internal + 154;
      // cast expressions
      int IllegalCast = TypeRelated + 156;
      // allocations
      int InvalidClassInstantiation = TypeRelated + 157;
      int CannotDefineDimensionExpressionsWithInit = Internal + 158;
      int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159;
      // operators
      int InvalidOperator = Internal + 160;
      // statements
      int CodeCannotBeReached = Internal + 161;
      int CannotReturnInInitializer = Internal + 162;
      int InitializerMustCompleteNormally = Internal + 163;
      // assert
      int InvalidVoidExpression = Internal + 164;
      // try
      int MaskedCatch = TypeRelated + 165;
      int DuplicateDefaultCase = Internal + 166;
      int UnreachableCatch = TypeRelated + MethodRelated + 167;
      int UnhandledException = TypeRelated + 168;
      // switch       
      int IncorrectSwitchType = TypeRelated + 169;
      int DuplicateCase = FieldRelated + 170;

      // labelled
      int DuplicateLabel = Internal + 171;
      int InvalidBreak = Internal + 172;
      int InvalidContinue = Internal + 173;
      int UndefinedLabel = Internal + 174;
      //synchronized
      int InvalidTypeToSynchronized = Internal + 175;
      int InvalidNullToSynchronized = Internal + 176;
      // throw
      int CannotThrowNull = Internal + 177;
      // assignment
      /** @since 2.1 */
00422       int AssignmentHasNoEffect = Internal + 178;
      /** @since 3.0 */
00424       int PossibleAccidentalBooleanAssignment = Internal + 179;
      /** @since 3.0 */
00426       int SuperfluousSemicolon = Internal + 180;
      /** @since 3.0 */
00428       int UnnecessaryCast = Internal + TypeRelated + 181;
      /** @deprecated - no longer generated, simply treated as UnnecessaryCast
       *   @since 3.0 */
00431       int UnnecessaryArgumentCast = Internal + TypeRelated + 182;
      /** @since 3.0 */
00433       int UnnecessaryInstanceof = Internal + TypeRelated + 183;   
      /** @since 3.0 */
00435       int FinallyMustCompleteNormally = Internal + 184;     
      /** @since 3.0 */
00437       int UnusedMethodDeclaredThrownException = Internal + 185;   
      /** @since 3.0 */
00439       int UnusedConstructorDeclaredThrownException = Internal + 186;    
      /** @since 3.0 */
00441       int InvalidCatchBlockSequence = Internal + TypeRelated + 187;
      /** @since 3.0 */
00443       int EmptyControlFlowStatement = Internal + TypeRelated + 188;     
      /** @since 3.0 */
00445       int UnnecessaryElse = Internal + 189;     

      // inner emulation
      int NeedToEmulateFieldReadAccess = FieldRelated + 190;
      int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
      int NeedToEmulateMethodAccess = MethodRelated + 192;
      int NeedToEmulateConstructorAccess = MethodRelated + 193;

      /** @since 3.2 */
00454       int FallthroughCase = Internal + 194;     
      
      //inherited name hides enclosing name (sort of ambiguous)
      int InheritedMethodHidesEnclosingName = MethodRelated + 195;
      int InheritedFieldHidesEnclosingName = FieldRelated + 196;
      int InheritedTypeHidesEnclosingName = TypeRelated + 197;

      /** @since 3.1 */
00462       int IllegalUsageOfQualifiedTypeReference = Internal + Syntax + 198;

      // miscellaneous
      /** @since 3.2 */
00466       int UnusedLabel = Internal + 199;
      int ThisInStaticContext = Internal + 200;
      int StaticMethodRequested = Internal + MethodRelated + 201;
      int IllegalDimension = Internal + 202;
      int InvalidTypeExpression = Internal + 203;
      int ParsingError = Syntax + Internal + 204;
      int ParsingErrorNoSuggestion = Syntax + Internal + 205;
      int InvalidUnaryExpression = Syntax + Internal + 206;

      // syntax errors
      int InterfaceCannotHaveConstructors = Syntax + Internal + 207;
      int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208;
      int ParsingErrorOnKeyword = Syntax + Internal + 209;  
      int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;

      int UnmatchedBracket = Syntax + Internal + 220;
      int NoFieldOnBaseType = FieldRelated + 221;
      int InvalidExpressionAsStatement = Syntax + Internal + 222;
      /** @since 2.1 */
00485       int ExpressionShouldBeAVariable = Syntax + Internal + 223;
      /** @since 2.1 */
00487       int MissingSemiColon = Syntax + Internal + 224;
      /** @since 2.1 */
00489       int InvalidParenthesizedExpression = Syntax + Internal + 225;
      
      /** @since 3.0 */
00492       int ParsingErrorInsertTokenBefore = Syntax + Internal + 230;
      /** @since 3.0 */
00494       int ParsingErrorInsertTokenAfter = Syntax + Internal + 231;
      /** @since 3.0 */
00496     int ParsingErrorDeleteToken = Syntax + Internal + 232;
    /** @since 3.0 */
00498     int ParsingErrorDeleteTokens = Syntax + Internal + 233;
    /** @since 3.0 */
00500     int ParsingErrorMergeTokens = Syntax + Internal + 234;
    /** @since 3.0 */
00502     int ParsingErrorInvalidToken = Syntax + Internal + 235;
    /** @since 3.0 */
00504     int ParsingErrorMisplacedConstruct = Syntax + Internal + 236;
    /** @since 3.0 */
00506     int ParsingErrorReplaceTokens = Syntax + Internal + 237;
    /** @since 3.0 */
00508     int ParsingErrorNoSuggestionForTokens = Syntax + Internal + 238;
    /** @since 3.0 */
00510     int ParsingErrorUnexpectedEOF = Syntax + Internal + 239;
    /** @since 3.0 */
00512     int ParsingErrorInsertToComplete = Syntax + Internal + 240;
    /** @since 3.0 */
00514     int ParsingErrorInsertToCompleteScope = Syntax + Internal + 241;
    /** @since 3.0 */
00516     int ParsingErrorInsertToCompletePhrase = Syntax + Internal + 242;
    
      // scanner errors
      int EndOfSource = Syntax + Internal + 250;
      int InvalidHexa = Syntax + Internal + 251;
      int InvalidOctal = Syntax + Internal + 252;
      int InvalidCharacterConstant = Syntax + Internal + 253;
      int InvalidEscape = Syntax + Internal + 254;
      int InvalidInput = Syntax + Internal + 255;
      int InvalidUnicodeEscape = Syntax + Internal + 256;
      int InvalidFloat = Syntax + Internal + 257;
      int NullSourceString = Syntax + Internal + 258;
      int UnterminatedString = Syntax + Internal + 259;
      int UnterminatedComment = Syntax + Internal + 260;
      int NonExternalizedStringLiteral = Internal + 261;
      /** @since 3.1 */
00532       int InvalidDigit = Syntax + Internal + 262;     
      /** @since 3.1 */
00534       int InvalidLowSurrogate = Syntax + Internal + 263;
      /** @since 3.1 */
00536       int InvalidHighSurrogate = Syntax + Internal + 264;
      /** @since 3.2 */
00538       int UnnecessaryNLSTag = Internal + 265;

      // type related problems
      /** @since 3.1 */
00542       int DiscouragedReference = TypeRelated + 280;

      int InterfaceCannotHaveInitializers = TypeRelated + 300;
      int DuplicateModifierForType = TypeRelated + 301;
      int IllegalModifierForClass = TypeRelated + 302;
      int IllegalModifierForInterface = TypeRelated + 303;
      int IllegalModifierForMemberClass = TypeRelated + 304;
      int IllegalModifierForMemberInterface = TypeRelated + 305;
      int IllegalModifierForLocalClass = TypeRelated + 306;
      /** @since 3.1 */
00552       int ForbiddenReference = TypeRelated + 307;
      int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308;
      int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309;
      int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310;
      int IllegalStaticModifierForMemberType = TypeRelated + 311;
      int SuperclassMustBeAClass = TypeRelated + 312;
      int ClassExtendFinalClass = TypeRelated + 313;
      int DuplicateSuperInterface = TypeRelated + 314;
      int SuperInterfaceMustBeAnInterface = TypeRelated + 315;
      int HierarchyCircularitySelfReference = TypeRelated + 316;
      int HierarchyCircularity = TypeRelated + 317;
      int HidingEnclosingType = TypeRelated + 318;
      int DuplicateNestedType = TypeRelated + 319;
      int CannotThrowType = TypeRelated + 320;
      int PackageCollidesWithType = TypeRelated + 321;
      int TypeCollidesWithPackage = TypeRelated + 322;
      int DuplicateTypes = TypeRelated + 323;
      int IsClassPathCorrect = TypeRelated + 324;
      int PublicClassMustMatchFileName = TypeRelated + 325;
      int MustSpecifyPackage = Internal + 326;
      int HierarchyHasProblems = TypeRelated + 327;
      int PackageIsNotExpectedPackage = Internal + 328;
      /** @since 2.1 */
00575       int ObjectCannotHaveSuperTypes = Internal + 329;
      /** @since 3.1 */
00577       int ObjectMustBeClass = Internal + 330;

      /** @deprecated - problem is no longer generated, UndefinedType is used instead */
00580       int SuperclassNotFound =  TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00582       int SuperclassNotVisible =  TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00584       int SuperclassAmbiguous =  TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00586       int SuperclassInternalNameProvided =  TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00588       int SuperclassInheritedNameHidesEnclosingName =  TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334

      /** @deprecated - problem is no longer generated, UndefinedType is used instead */
00591       int InterfaceNotFound =  TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00593       int InterfaceNotVisible =  TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00595       int InterfaceAmbiguous =  TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00597       int InterfaceInternalNameProvided =  TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00599       int InterfaceInheritedNameHidesEnclosingName =  TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339

      // field related problems
      int DuplicateField = FieldRelated + 340;
      int DuplicateModifierForField = FieldRelated + 341;
      int IllegalModifierForField = FieldRelated + 342;
      int IllegalModifierForInterfaceField = FieldRelated + 343;
      int IllegalVisibilityModifierCombinationForField = FieldRelated + 344;
      int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345;
      int UnexpectedStaticModifierForField = FieldRelated + 346;

      /** @deprecated - problem is no longer generated, UndefinedType is used instead */
00611       int FieldTypeNotFound =  FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00613       int FieldTypeNotVisible =  FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00615       int FieldTypeAmbiguous =  FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00617       int FieldTypeInternalNameProvided =  FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00619       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;

      /** @deprecated - problem is no longer generated, UndefinedType is used instead */
00638       int ArgumentTypeNotFound =  MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00640       int ArgumentTypeNotVisible =  MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00642       int ArgumentTypeAmbiguous =  MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00644       int ArgumentTypeInternalNameProvided =  MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00646       int ArgumentTypeInheritedNameHidesEnclosingName =  MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374

      /** @deprecated - problem is no longer generated, UndefinedType is used instead */
00649       int ExceptionTypeNotFound =  MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00651       int ExceptionTypeNotVisible =  MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00653       int ExceptionTypeAmbiguous =  MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00655       int ExceptionTypeInternalNameProvided =  MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00657       int ExceptionTypeInheritedNameHidesEnclosingName =  MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379

      /** @deprecated - problem is no longer generated, UndefinedType is used instead */
00660       int ReturnTypeNotFound =  MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00662       int ReturnTypeNotVisible =  MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00664       int ReturnTypeAmbiguous =  MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00666       int ReturnTypeInternalNameProvided =  MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00668       int ReturnTypeInheritedNameHidesEnclosingName =  MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384

      // import related problems
      int ConflictingImport = ImportRelated + 385;
      int DuplicateImport = ImportRelated + 386;
      int CannotImportPackage = ImportRelated + 387;
      int UnusedImport = ImportRelated + 388;

      int ImportNotFound =  ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
      /** @deprecated - problem is no longer generated, NotVisibleType is used instead */
00678       int ImportNotVisible =  ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
      /** @deprecated - problem is no longer generated, use AmbiguousType is used instead */
00680       int ImportAmbiguous =  ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
      /** @deprecated - problem is no longer generated, use InternalTypeNameProvided is used instead */
00682       int ImportInternalNameProvided =  ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
      /** @deprecated - problem is no longer generated, use InheritedTypeHidesEnclosingName is used instead */
00684       int ImportInheritedNameHidesEnclosingName =  ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394

      /** @since 3.1 */
00687       int InvalidTypeForStaticImport =  ImportRelated + 391;

      // local variable related problems
      int DuplicateModifierForVariable = MethodRelated + 395;
      int IllegalModifierForVariable = MethodRelated + 396;
      /** @since 3.1 */
00693       int LocalVariableCannotBeNull = Internal + 397;
      /** @since 3.1 */
00695       int LocalVariableCanOnlyBeNull = Internal + 398;
      /** @since 3.2 */
00697       int LocalVariableMayBeNull = Internal + 399;

      // method verifier problems
      int AbstractMethodMustBeImplemented = MethodRelated + 400;
      int FinalMethodCannotBeOverridden = MethodRelated + 401;
      int IncompatibleExceptionInThrowsClause = MethodRelated + 402;
      int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403;
      int IncompatibleReturnType = MethodRelated + 404;
      int InheritedMethodReducesVisibility = MethodRelated + 405;
      int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406;
      int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407;
      int StaticInheritedMethodConflicts = MethodRelated + 408;
      int MethodReducesVisibility = MethodRelated + 409;
      int OverridingNonVisibleMethod = MethodRelated + 410;
      int AbstractMethodCannotBeOverridden = MethodRelated + 411;
      int OverridingDeprecatedMethod = MethodRelated + 412;
      /** @since 2.1 */
00714       int IncompatibleReturnTypeForNonInheritedInterfaceMethod = MethodRelated + 413;
      /** @since 2.1 */
00716       int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod = MethodRelated + 414;
      /** @since 3.1 */
00718       int IllegalVararg = MethodRelated + 415;

      // code snippet support
      int CodeSnippetMissingClass = Internal + 420;
      int CodeSnippetMissingMethod = Internal + 421;
      int CannotUseSuperInCodeSnippet = Internal + 422;
      
      //constant pool
      int TooManyConstantsInConstantPool = Internal + 430;
      /** @since 2.1 */
00728       int TooManyBytesForStringConstant = Internal + 431;

      // static constraints
      /** @since 2.1 */
00732       int TooManyFields = Internal + 432;
      /** @since 2.1 */
00734       int TooManyMethods = Internal + 433; 
            
      // 1.4 features
      // assertion warning
      int UseAssertAsAnIdentifier = Internal + 440;
      
      // 1.5 features
      int UseEnumAsAnIdentifier = Internal + 441;
      /** @since 3.2 */
00743       int EnumConstantsCannotBeSurroundedByParenthesis = Syntax + Internal + 442;
      
      // detected task
      /** @since 2.1 */
00747       int Task = Internal + 450;
      
      // block
      /** @since 3.0 */
00751       int UndocumentedEmptyBlock = Internal + 460;
            
      /*
       * Javadoc comments
       */
      /** @since 3.2 */
00757       int JavadocMissingIdentifier = Javadoc + Internal + 467;
      /** @since 3.2 */
00759       int JavadocNonStaticTypeFromStaticInvocation = Javadoc + Internal + 468;
      /** @since 3.1 */
00761       int JavadocInvalidParamTagTypeParameter = Javadoc + Internal + 469;
      /** @since 3.0 */
00763       int JavadocUnexpectedTag = Javadoc + Internal + 470;
      /** @since 3.0 */
00765       int JavadocMissingParamTag = Javadoc + Internal + 471;
      /** @since 3.0 */
00767       int JavadocMissingParamName = Javadoc + Internal + 472;
      /** @since 3.0 */
00769       int JavadocDuplicateParamName = Javadoc + Internal + 473;
      /** @since 3.0 */
00771       int JavadocInvalidParamName = Javadoc + Internal + 474;
      /** @since 3.0 */
00773       int JavadocMissingReturnTag = Javadoc + Internal + 475;
      /** @since 3.0 */
00775       int JavadocDuplicateReturnTag = Javadoc + Internal + 476;
      /** @since 3.0 */
00777       int JavadocMissingThrowsTag = Javadoc + Internal + 477;
      /** @since 3.0 */
00779       int JavadocMissingThrowsClassName = Javadoc + Internal + 478;
      /** @since 3.0 */
00781       int JavadocInvalidThrowsClass = Javadoc + Internal + 479;
      /** @since 3.0 */
00783       int JavadocDuplicateThrowsClassName = Javadoc + Internal + 480;
      /** @since 3.0 */
00785       int JavadocInvalidThrowsClassName = Javadoc + Internal + 481;
      /** @since 3.0 */
00787       int JavadocMissingSeeReference = Javadoc + Internal + 482;
      /** @since 3.0 */
00789       int JavadocInvalidSeeReference = Javadoc + Internal + 483;
      /** @since 3.0 */
00791       int JavadocInvalidSeeHref = Javadoc + Internal + 484;
      /** @since 3.0 */
00793       int JavadocInvalidSeeArgs = Javadoc + Internal + 485;
      /** @since 3.0 */
00795       int JavadocMissing = Javadoc + Internal + 486;
      /** @since 3.0 */
00797       int JavadocInvalidTag = Javadoc + Internal + 487;
      /*
       * ID for field errors in Javadoc
       */
      /** @since 3.0 */
00802       int JavadocUndefinedField = Javadoc + Internal + 488;
      /** @since 3.0 */
00804       int JavadocNotVisibleField = Javadoc + Internal + 489;
      /** @since 3.0 */
00806       int JavadocAmbiguousField = Javadoc + Internal + 490;
      /** @since 3.0 */
00808       int JavadocUsingDeprecatedField = Javadoc + Internal + 491;
      /*
       * IDs for constructor errors in Javadoc
       */
      /** @since 3.0 */
00813       int JavadocUndefinedConstructor = Javadoc + Internal + 492;
      /** @since 3.0 */
00815       int JavadocNotVisibleConstructor = Javadoc + Internal + 493;
      /** @since 3.0 */
00817       int JavadocAmbiguousConstructor = Javadoc + Internal + 494;
      /** @since 3.0 */
00819       int JavadocUsingDeprecatedConstructor = Javadoc + Internal + 495;
      /*
       * IDs for method errors in Javadoc
       */
      /** @since 3.0 */
00824       int JavadocUndefinedMethod = Javadoc + Internal + 496;
      /** @since 3.0 */
00826       int JavadocNotVisibleMethod = Javadoc + Internal + 497;
      /** @since 3.0 */
00828       int JavadocAmbiguousMethod = Javadoc + Internal + 498;
      /** @since 3.0 */
00830       int JavadocUsingDeprecatedMethod = Javadoc + Internal + 499;
      /** @since 3.0 */
00832       int JavadocNoMessageSendOnBaseType = Javadoc + Internal + 500;
      /** @since 3.0 */
00834       int JavadocParameterMismatch = Javadoc + Internal + 501;
      /** @since 3.0 */
00836       int JavadocNoMessageSendOnArrayType = Javadoc + Internal + 502;
      /*
       * IDs for type errors in Javadoc
       */
      /** @since 3.0 */
00841       int JavadocUndefinedType = Javadoc + Internal + 503;
      /** @since 3.0 */
00843       int JavadocNotVisibleType = Javadoc + Internal + 504;
      /** @since 3.0 */
00845       int JavadocAmbiguousType = Javadoc + Internal + 505;
      /** @since 3.0 */
00847       int JavadocUsingDeprecatedType = Javadoc + Internal + 506;
      /** @since 3.0 */
00849       int JavadocInternalTypeNameProvided = Javadoc + Internal + 507;
      /** @since 3.0 */
00851       int JavadocInheritedMethodHidesEnclosingName = Javadoc + Internal + 508;
      /** @since 3.0 */
00853       int JavadocInheritedFieldHidesEnclosingName = Javadoc + Internal + 509;
      /** @since 3.0 */
00855       int JavadocInheritedNameHidesEnclosingTypeName = Javadoc + Internal + 510;
      /** @since 3.0 */
00857       int JavadocAmbiguousMethodReference = Javadoc + Internal + 511;
      /** @since 3.0 */
00859       int JavadocUnterminatedInlineTag = Javadoc + Internal + 512;
      /** @since 3.0 */
00861       int JavadocMalformedSeeReference = Javadoc + Internal + 513;
      /** @since 3.0 */
00863       int JavadocMessagePrefix = Internal + 514;

      /** @since 3.1 */
00866       int JavadocMissingHashCharacter = Javadoc + Internal + 515;
      /** @since 3.1 */
00868       int JavadocEmptyReturnTag = Javadoc + Internal + 516;
      /** @since 3.1 */
00870       int JavadocInvalidValueReference = Javadoc + Internal + 517;
      /** @since 3.1 */
00872       int JavadocUnexpectedText = Javadoc + Internal + 518;
      /** @since 3.1 */
00874       int JavadocInvalidParamTagName = Javadoc + Internal + 519;

      /**
       * Generics
       */
      /** @since 3.1 */
00880       int DuplicateTypeVariable = Internal + 520;
      /** @since 3.1 */
00882       int IllegalTypeVariableSuperReference = Internal + 521;
      /** @since 3.1 */
00884       int NonStaticTypeFromStaticInvocation = Internal + 522;
      /** @since 3.1 */
00886       int ObjectCannotBeGeneric = Internal + 523;
      /** @since 3.1 */
00888       int NonGenericType = TypeRelated + 524;
      /** @since 3.1 */
00890       int IncorrectArityForParameterizedType = TypeRelated + 525;
      /** @since 3.1 */
00892       int TypeArgumentMismatch = TypeRelated + 526;
      /** @since 3.1 */
00894       int DuplicateMethodErasure = TypeRelated + 527;
      /** @since 3.1 */
00896       int ReferenceToForwardTypeVariable = TypeRelated + 528;
    /** @since 3.1 */
00898       int BoundMustBeAnInterface = TypeRelated + 529; 
    /** @since 3.1 */
00900       int UnsafeRawConstructorInvocation = TypeRelated + 530;
    /** @since 3.1 */
00902       int UnsafeRawMethodInvocation = TypeRelated + 531;
    /** @since 3.1 */
00904       int UnsafeTypeConversion = TypeRelated + 532;
    /** @since 3.1 */
00906       int InvalidTypeVariableExceptionType = TypeRelated + 533;
      /** @since 3.1 */
00908       int InvalidParameterizedExceptionType = TypeRelated + 534;
      /** @since 3.1 */
00910       int IllegalGenericArray = TypeRelated + 535;
      /** @since 3.1 */
00912       int UnsafeRawFieldAssignment = TypeRelated + 536;
      /** @since 3.1 */
00914       int FinalBoundForTypeVariable = TypeRelated + 537;
      /** @since 3.1 */
00916       int UndefinedTypeVariable = Internal + 538;
      /** @since 3.1 */
00918       int SuperInterfacesCollide = TypeRelated + 539;
      /** @since 3.1 */
00920       int WildcardConstructorInvocation = TypeRelated + 540;
      /** @since 3.1 */
00922       int WildcardMethodInvocation = TypeRelated + 541;
      /** @since 3.1 */
00924       int WildcardFieldAssignment = TypeRelated + 542;
      /** @since 3.1 */
00926       int GenericMethodTypeArgumentMismatch = TypeRelated + 543;
      /** @since 3.1 */
00928       int GenericConstructorTypeArgumentMismatch = TypeRelated + 544;
      /** @since 3.1 */
00930       int UnsafeGenericCast = TypeRelated + 545;
      /** @since 3.1 */
00932       int IllegalInstanceofParameterizedType = Internal + 546;
      /** @since 3.1 */
00934       int IllegalInstanceofTypeParameter = Internal + 547;
      /** @since 3.1 */
00936       int NonGenericMethod = TypeRelated + 548;
      /** @since 3.1 */
00938       int IncorrectArityForParameterizedMethod = TypeRelated + 549;
      /** @since 3.1 */
00940       int ParameterizedMethodArgumentTypeMismatch = TypeRelated + 550;
      /** @since 3.1 */
00942       int NonGenericConstructor = TypeRelated + 551;
      /** @since 3.1 */
00944       int IncorrectArityForParameterizedConstructor = TypeRelated + 552;
      /** @since 3.1 */
00946       int ParameterizedConstructorArgumentTypeMismatch = TypeRelated + 553;
      /** @since 3.1 */
00948       int TypeArgumentsForRawGenericMethod = TypeRelated + 554;
      /** @since 3.1 */
00950       int TypeArgumentsForRawGenericConstructor = TypeRelated + 555;
      /** @since 3.1 */
00952       int SuperTypeUsingWildcard = TypeRelated + 556;
      /** @since 3.1 */
00954       int GenericTypeCannotExtendThrowable = TypeRelated + 557;
      /** @since 3.1 */
00956       int IllegalClassLiteralForTypeVariable = TypeRelated + 558;
      /** @since 3.1 */
00958       int UnsafeReturnTypeOverride = MethodRelated + 559;
      /** @since 3.1 */
00960       int MethodNameClash = MethodRelated + 560;
      /** @since 3.1 */
00962       int RawMemberTypeCannotBeParameterized = TypeRelated + 561;
      /** @since 3.1 */
00964       int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;     
      /** @since 3.1 */
00966       int StaticMemberOfParameterizedType = TypeRelated + 563;    
    /** @since 3.1 */
00968       int BoundHasConflictingArguments = TypeRelated + 564; 
    /** @since 3.1 */
00970       int DuplicateParameterizedMethods = MethodRelated + 565;
      /** @since 3.1 */
00972       int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;
      /** @since 3.1 */
00974       int DuplicateBounds = TypeRelated + 567;
      /** @since 3.1 */
00976       int BoundCannotBeArray = TypeRelated + 568;
    /** @since 3.1 */
00978       int UnsafeRawGenericConstructorInvocation = TypeRelated + 569;
    /** @since 3.1 */
00980       int UnsafeRawGenericMethodInvocation = TypeRelated + 570;
      /** @since 3.1 */
00982       int TypeParameterHidingType = TypeRelated + 571;
      /** @since 3.2 */
00984       int RawTypeReference = TypeRelated + 572;
      /** @since 3.2 */
00986       int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;
      /** @since 3.2 */
00988       int UnsafeGenericArrayForVarargs = MethodRelated + 574;
      /** @since 3.2 */
00990       int IllegalAccessFromTypeVariable = TypeRelated + 575;
      
      /**
       * Foreach
       */
      /** @since 3.1 */ 
00996       int IncompatibleTypesInForeach = TypeRelated + 580;   
      /** @since 3.1 */
00998       int InvalidTypeForCollection = Internal + 581;
      
      /**
       * 1.5 Syntax errors (when source level < 1.5)
       */
      /** @since 3.1 */
01004     int InvalidUsageOfTypeParameters = Syntax + Internal + 590;
    /** @since 3.1 */
01006     int InvalidUsageOfStaticImports = Syntax + Internal + 591;
    /** @since 3.1 */
01008     int InvalidUsageOfForeachStatements = Syntax + Internal + 592;
    /** @since 3.1 */
01010     int InvalidUsageOfTypeArguments = Syntax + Internal + 593;
    /** @since 3.1 */
01012     int InvalidUsageOfEnumDeclarations = Syntax + Internal + 594;
    /** @since 3.1 */
01014     int InvalidUsageOfVarargs = Syntax + Internal + 595;
    /** @since 3.1 */
01016     int InvalidUsageOfAnnotations = Syntax + Internal + 596;
    /** @since 3.1 */
01018     int InvalidUsageOfAnnotationDeclarations = Syntax + Internal + 597;
    
    /**
     * Annotation
     */
      /** @since 3.1 */
01024       int IllegalModifierForAnnotationMethod = MethodRelated + 600;
    /** @since 3.1 */
01026     int IllegalExtendedDimensions = MethodRelated + 601;
    /** @since 3.1 */
01028       int InvalidFileNameForPackageAnnotations = Syntax + Internal + 602;
    /** @since 3.1 */
01030       int IllegalModifierForAnnotationType = TypeRelated + 603;
    /** @since 3.1 */
01032       int IllegalModifierForAnnotationMemberType = TypeRelated + 604;
    /** @since 3.1 */
01034       int InvalidAnnotationMemberType = TypeRelated + 605;  
    /** @since 3.1 */
01036       int AnnotationCircularitySelfReference = TypeRelated + 606;
    /** @since 3.1 */
01038       int AnnotationCircularity = TypeRelated + 607;
      /** @since 3.1 */
01040       int DuplicateAnnotation = TypeRelated + 608;
      /** @since 3.1 */
01042       int MissingValueForAnnotationMember = TypeRelated + 609;
      /** @since 3.1 */
01044       int DuplicateAnnotationMember = Internal + 610;
      /** @since 3.1 */
01046       int UndefinedAnnotationMember = MethodRelated + 611;
      /** @since 3.1 */
01048       int AnnotationValueMustBeClassLiteral = Internal + 612;
      /** @since 3.1 */
01050       int AnnotationValueMustBeConstant = Internal + 613;
      /** @deprecated - problem is no longer generated (code is legite)
       *   @since 3.1 */
01053       int AnnotationFieldNeedConstantInitialization = Internal + 614;
      /** @since 3.1 */
01055       int IllegalModifierForAnnotationField = Internal + 615;
      /** @since 3.1 */
01057       int AnnotationCannotOverrideMethod = MethodRelated + 616;
      /** @since 3.1 */
01059       int AnnotationMembersCannotHaveParameters = Syntax + Internal + 617;
      /** @since 3.1 */
01061       int AnnotationMembersCannotHaveTypeParameters = Syntax + Internal + 618;
      /** @since 3.1 */
01063       int AnnotationTypeDeclarationCannotHaveSuperclass = Syntax + Internal + 619;
      /** @since 3.1 */
01065       int AnnotationTypeDeclarationCannotHaveSuperinterfaces = Syntax + Internal + 620;
      /** @since 3.1 */
01067       int DuplicateTargetInTargetAnnotation = Internal + 621;
      /** @since 3.1 */
01069       int DisallowedTargetForAnnotation = TypeRelated + 622;
      /** @since 3.1 */
01071       int MethodMustOverride = MethodRelated + 623;
      /** @since 3.1 */
01073       int AnnotationTypeDeclarationCannotHaveConstructor = Syntax + Internal + 624;
      /** @since 3.1 */
01075       int AnnotationValueMustBeAnnotation = Internal + 625;
      /** @since 3.1 */
01077       int AnnotationTypeUsedAsSuperInterface = TypeRelated + 626;
      /** @since 3.1 */
01079       int MissingOverrideAnnotation = MethodRelated + 627;
      /** @since 3.1 */
01081       int FieldMissingDeprecatedAnnotation = Internal + 628;
      /** @since 3.1 */
01083       int MethodMissingDeprecatedAnnotation = Internal + 629;
      /** @since 3.1 */
01085       int TypeMissingDeprecatedAnnotation = Internal + 630;
      /** @since 3.1 */
01087       int UnhandledWarningToken = Internal + 631;
      /** @since 3.2 */
01089       int AnnotationValueMustBeArrayInitializer = Internal + 632;
      
      /**
       * Corrupted binaries
       */
      /** @since 3.1 */
01095       int CorruptedSignature = Internal + 700;
      /**
       * Corrupted source
       */
      /** @since 3.2 */
01100       int InvalidEncoding = Internal + 701;
      /** @since 3.2 */
01102       int CannotReadSource = Internal + 702;

      /**
       * Autoboxing
       */
      /** @since 3.1 */
01108       int BoxingConversion = Internal + 720;
      /** @since 3.1 */
01110       int UnboxingConversion = Internal + 721;
      
      /**
       * Enum
       */
      /** @since 3.1 */
01116       int IllegalModifierForEnum = TypeRelated + 750;
      /** @since 3.1 */
01118       int IllegalModifierForEnumConstant = FieldRelated + 751;    
      /** @since 3.1 */
01120       int IllegalModifierForLocalEnum = TypeRelated + 752;
      /** @since 3.1 */
01122       int IllegalModifierForMemberEnum = TypeRelated + 753;
      /** @since 3.1 */
01124       int CannotDeclareEnumSpecialMethod = MethodRelated + 754;
      /** @since 3.1 */
01126       int IllegalQualifiedEnumConstantLabel = FieldRelated + 755;
      /** @since 3.1 */
01128       int CannotExtendEnum = TypeRelated + 756;
      /** @since 3.1 */
01130       int CannotInvokeSuperConstructorInEnum = MethodRelated + 757;
      /** @since 3.1 */
01132       int EnumAbstractMethodMustBeImplemented = MethodRelated + 758;
      /** @since 3.1 */
01134       int EnumSwitchCannotTargetField = FieldRelated + 759;
      /** @since 3.1 */
01136       int IllegalModifierForEnumConstructor = MethodRelated + 760;
      /** @since 3.1 */
01138       int MissingEnumConstantCase = FieldRelated + 761;
      /** @since 3.2 */ // TODO need to fix 3.1.1 contribution (inline this constant on client side)
01140       int EnumStaticFieldInInInitializerContext = FieldRelated + 762;
      
      /**
       * Var args
       */
      /** @since 3.1 */
01146       int IllegalExtendedDimensionsForVarArgs = Syntax + Internal + 800;
      /** @since 3.1 */
01148       int MethodVarargsArgumentNeedCast = MethodRelated + 801;
      /** @since 3.1 */
01150       int ConstructorVarargsArgumentNeedCast = ConstructorRelated + 802;
      /** @since 3.1 */
01152       int VarargsConflict = MethodRelated + 803;
      
      /**
       * Javadoc Generic
       */
      /** @since 3.1 */
01158       int JavadocGenericMethodTypeArgumentMismatch = Javadoc + Internal + 850;
      /** @since 3.1 */
01160       int JavadocNonGenericMethod = Javadoc + Internal + 851;
      /** @since 3.1 */
01162       int JavadocIncorrectArityForParameterizedMethod = Javadoc + Internal + 852;
      /** @since 3.1 */
01164       int JavadocParameterizedMethodArgumentTypeMismatch = Javadoc + Internal + 853;
      /** @since 3.1 */
01166       int JavadocTypeArgumentsForRawGenericMethod = Javadoc + Internal + 854;
      /** @since 3.1 */
01168       int JavadocGenericConstructorTypeArgumentMismatch = Javadoc + Internal + 855;
      /** @since 3.1 */
01170       int JavadocNonGenericConstructor = Javadoc + Internal + 856;
      /** @since 3.1 */
01172       int JavadocIncorrectArityForParameterizedConstructor = Javadoc + Internal + 857;
      /** @since 3.1 */
01174       int JavadocParameterizedConstructorArgumentTypeMismatch = Javadoc + Internal + 858;
      /** @since 3.1 */
01176       int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;

      /**
       * External problems -- These are problems defined by other plugins
       */

      /** @since 3.2 */
01183       int ExternalProblemNotFixable = 900;

      // indicates an externally defined problem that has a quick-assist processor
      // associated with it
      /** @since 3.2 */
01188       int ExternalProblemFixable = 901;
}

Generated by  Doxygen 1.6.0   Back to index