X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Feclipse%2Fjdt%2Fcore%2Fcompiler%2FIProblem.java;fp=src%2Forg%2Feclipse%2Fjdt%2Fcore%2Fcompiler%2FIProblem.java;h=7be59f139ad9d23a73cc86ea75a5598f6ea785c8;hb=040fa5af2cd00017cf3575950cdaade34a6d7f6c;hp=0000000000000000000000000000000000000000;hpb=a580fb8376d315d05e4d6bfdff9ff1101a151cd6;p=org.ibex.tool.git diff --git a/src/org/eclipse/jdt/core/compiler/IProblem.java b/src/org/eclipse/jdt/core/compiler/IProblem.java new file mode 100644 index 0000000..7be59f1 --- /dev/null +++ b/src/org/eclipse/jdt/core/compiler/IProblem.java @@ -0,0 +1,800 @@ +/******************************************************************************* + * Copyright (c) 2000, 2004 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Common Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/cpl-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 + ****************************************************************************/ +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: + * + * + * Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder + * so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected + * when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular + * their ID (attribute "id") is set to one of the IDs defined on this interface. + * + * @since 2.0 + */ +public interface IProblem { + + /** + * 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. + */ + int TypeRelated = 0x01000000; + int FieldRelated = 0x02000000; + int MethodRelated = 0x04000000; + int ConstructorRelated = 0x08000000; + int ImportRelated = 0x10000000; + int Internal = 0x20000000; + int Syntax = 0x40000000; + /** + * @since 3.0 + */ + int Javadoc = 0x80000000; + + /** + * Mask to use in order to filter out the category portion of the problem ID. + */ + int IgnoreCategoriesMask = 0xFFFFFF; + + /** + * Below are listed all available problem IDs. Note that this list could be augmented in the future, + * as new features are added to the Java core implementation. + */ + + /** + * ID reserved for referencing an internal error inside the JavaCore implementation which + * may be surfaced as a problem associated with the compilation unit which caused it to occur. + */ + int Unclassified = 0; + + /** + * General type related problems + */ + int ObjectHasNoSuperclass = TypeRelated + 1; + int UndefinedType = TypeRelated + 2; + int NotVisibleType = TypeRelated + 3; + int AmbiguousType = TypeRelated + 4; + int UsingDeprecatedType = TypeRelated + 5; + int InternalTypeNameProvided = TypeRelated + 6; + /** @since 2.1 */ + int UnusedPrivateType = Internal + TypeRelated + 7; + + int IncompatibleTypesInEqualityOperator = TypeRelated + 15; + int IncompatibleTypesInConditionalOperator = TypeRelated + 16; + int TypeMismatch = TypeRelated + 17; + /** @since 3.0 */ + int IndirectAccessToStaticType = Internal + TypeRelated + 18; + + /** + * Inner types related problems + */ + int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20; + int MissingEnclosingInstance = TypeRelated + 21; + int IncorrectEnclosingInstanceReference = TypeRelated + 22; + int IllegalEnclosingInstanceSpecification = TypeRelated + 23; + int CannotDefineStaticInitializerInLocalType = Internal + 24; + int OuterLocalMustBeFinal = Internal + 25; + int CannotDefineInterfaceInLocalType = Internal + 26; + int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27; + /** @since 2.1 */ + int EnclosingInstanceInConstructorCall = Internal + 28; + int AnonymousClassCannotExtendFinalClass = TypeRelated + 29; + + // variables + int UndefinedName = 50; + int UninitializedLocalVariable = Internal + 51; + int VariableTypeCannotBeVoid = Internal + 52; + int VariableTypeCannotBeVoidArray = Internal + 53; + int CannotAllocateVoidArray = Internal + 54; + // local variables + int RedefinedLocal = Internal + 55; + int RedefinedArgument = Internal + 56; + // final local variables + int DuplicateFinalLocalInitialization = Internal + 57; + /** @since 2.1 */ + int NonBlankFinalLocalAssignment = Internal + 58; + + int FinalOuterLocalAssignment = Internal + 60; + int LocalVariableIsNeverUsed = Internal + 61; + int ArgumentIsNeverUsed = Internal + 62; + int BytecodeExceeds64KLimit = Internal + 63; + int BytecodeExceeds64KLimitForClinit = Internal + 64; + int TooManyArgumentSlots = Internal + 65; + int TooManyLocalVariableSlots = Internal + 66; + /** @since 2.1 */ + int TooManySyntheticArgumentSlots = Internal + 67; + /** @since 2.1 */ + int TooManyArrayDimensions = Internal + 68; + /** @since 2.1 */ + int BytecodeExceeds64KLimitForConstructor = Internal + 69; + + // fields + int UndefinedField = FieldRelated + 70; + int NotVisibleField = FieldRelated + 71; + int AmbiguousField = FieldRelated + 72; + int UsingDeprecatedField = FieldRelated + 73; + int NonStaticFieldFromStaticInvocation = FieldRelated + 74; + int ReferenceToForwardField = FieldRelated + Internal + 75; + /** @since 2.1 */ + int NonStaticAccessToStaticField = Internal + FieldRelated + 76; + /** @since 2.1 */ + int UnusedPrivateField = Internal + FieldRelated + 77; + /** @since 3.0 */ + int IndirectAccessToStaticField = Internal + FieldRelated + 78; + /** @since 3.0 */ + int UnqualifiedFieldAccess = Internal + FieldRelated + 79; + + // blank final fields + int FinalFieldAssignment = FieldRelated + 80; + int UninitializedBlankFinalField = FieldRelated + 81; + int DuplicateBlankFinalFieldInitialization = FieldRelated + 82; + + // variable hiding + /** + * The local variable {0} is hiding another local variable defined in an enclosing type scope + * @since 3.0 + */ + int LocalVariableHidingLocalVariable = Internal + 90; + + /** + * The local variable {0} is hiding the field {1}.{2} + * @since 3.0 + */ + int LocalVariableHidingField = Internal + FieldRelated + 91; + + /** + * The field {0}.{1} is hiding another local variable defined in an enclosing type scope + * @since 3.0 + */ + int FieldHidingLocalVariable = Internal + FieldRelated + 92; + + /** + * The field {0}.{1} is hiding the field {2}.{3} + * @since 3.0 + */ + int FieldHidingField = Internal + FieldRelated + 93; + + /** + * The argument {0} is hiding another local variable defined in an enclosing type scope + * @since 3.0 + */ + int ArgumentHidingLocalVariable = Internal + 94; + + /** + * The argument {0} is hiding the field {2}.{3} + * @since 3.0 + */ + int ArgumentHidingField = Internal + 95; + + // methods + int UndefinedMethod = MethodRelated + 100; + int NotVisibleMethod = MethodRelated + 101; + int AmbiguousMethod = MethodRelated + 102; + int UsingDeprecatedMethod = MethodRelated + 103; + int DirectInvocationOfAbstractMethod = MethodRelated + 104; + int VoidMethodReturnsValue = MethodRelated + 105; + int MethodReturnsVoid = MethodRelated + 106; + int MethodRequiresBody = Internal + MethodRelated + 107; + int ShouldReturnValue = Internal + MethodRelated + 108; + int MethodButWithConstructorName = MethodRelated + 110; + int MissingReturnType = TypeRelated + 111; + int BodyForNativeMethod = Internal + MethodRelated + 112; + int BodyForAbstractMethod = Internal + MethodRelated + 113; + int NoMessageSendOnBaseType = MethodRelated + 114; + int ParameterMismatch = MethodRelated + 115; + int NoMessageSendOnArrayType = MethodRelated + 116; + /** @since 2.1 */ + int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117; + /** @since 2.1 */ + int UnusedPrivateMethod = Internal + MethodRelated + 118; + /** @since 3.0 */ + int IndirectAccessToStaticMethod = Internal + MethodRelated + 119; + + + // constructors + int UndefinedConstructor = ConstructorRelated + 130; + int NotVisibleConstructor = ConstructorRelated + 131; + int AmbiguousConstructor = ConstructorRelated + 132; + int UsingDeprecatedConstructor = ConstructorRelated + 133; + /** @since 2.1 */ + int UnusedPrivateConstructor = Internal + MethodRelated + 134; + // explicit constructor calls + int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135; + int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136; + int RecursiveConstructorInvocation = ConstructorRelated + 137; + int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138; + /** @since 3.0 */ + int InvalidExplicitConstructorCall = ConstructorRelated + Syntax + 139; + // implicit constructor calls + int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140; + int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141; + int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142; + int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143; + int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144; + int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145; + int UnhandledExceptionInDefaultConstructor = TypeRelated + 146; + int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147; + + // expressions + int ArrayReferenceRequired = Internal + 150; + int NoImplicitStringConversionForCharArrayExpression = Internal + 151; + // constant expressions + int StringConstantIsExceedingUtf8Limit = Internal + 152; + int NonConstantExpression = 153; + int NumericValueOutOfRange = Internal + 154; + // cast expressions + int IllegalCast = TypeRelated + 156; + // allocations + int InvalidClassInstantiation = TypeRelated + 157; + int CannotDefineDimensionExpressionsWithInit = Internal + 158; + int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159; + // operators + int InvalidOperator = Internal + 160; + // statements + int CodeCannotBeReached = Internal + 161; + int CannotReturnInInitializer = Internal + 162; + int InitializerMustCompleteNormally = Internal + 163; + // assert + int InvalidVoidExpression = Internal + 164; + // try + int MaskedCatch = TypeRelated + 165; + int DuplicateDefaultCase = 166; + int UnreachableCatch = TypeRelated + MethodRelated + 167; + int UnhandledException = TypeRelated + 168; + // switch + int IncorrectSwitchType = TypeRelated + 169; + int DuplicateCase = FieldRelated + 170; + // labelled + int DuplicateLabel = Internal + 171; + int InvalidBreak = Internal + 172; + int InvalidContinue = Internal + 173; + int UndefinedLabel = Internal + 174; + //synchronized + int InvalidTypeToSynchronized = Internal + 175; + int InvalidNullToSynchronized = Internal + 176; + // throw + int CannotThrowNull = Internal + 177; + // assignment + /** @since 2.1 */ + int AssignmentHasNoEffect = Internal + 178; + /** @since 3.0 */ + int PossibleAccidentalBooleanAssignment = Internal + 179; + /** @since 3.0 */ + int SuperfluousSemicolon = Internal + 180; + /** @since 3.0 */ + int UnnecessaryCast = Internal + TypeRelated + 181; + /** @since 3.0 */ + int UnnecessaryArgumentCast = Internal + TypeRelated + 182; + /** @since 3.0 */ + int UnnecessaryInstanceof = Internal + TypeRelated + 183; + /** @since 3.0 */ + int FinallyMustCompleteNormally = Internal + 184; + /** @since 3.0 */ + int UnusedMethodDeclaredThrownException = Internal + 185; + /** @since 3.0 */ + int UnusedConstructorDeclaredThrownException = Internal + 186; + /** @since 3.0 */ + int InvalidCatchBlockSequence = Internal + TypeRelated + 187; + /** @since 3.0 */ + int EmptyControlFlowStatement = Internal + TypeRelated + 188; + /** @since 3.0 */ + int UnnecessaryElse = Internal + 189; + + // inner emulation + int NeedToEmulateFieldReadAccess = FieldRelated + 190; + int NeedToEmulateFieldWriteAccess = FieldRelated + 191; + int NeedToEmulateMethodAccess = MethodRelated + 192; + int NeedToEmulateConstructorAccess = MethodRelated + 193; + + //inherited name hides enclosing name (sort of ambiguous) + int InheritedMethodHidesEnclosingName = MethodRelated + 195; + int InheritedFieldHidesEnclosingName = FieldRelated + 196; + int InheritedTypeHidesEnclosingName = TypeRelated + 197; + + // miscellaneous + int ThisInStaticContext = Internal + 200; + int StaticMethodRequested = Internal + MethodRelated + 201; + int IllegalDimension = Internal + 202; + int InvalidTypeExpression = Internal + 203; + int ParsingError = Syntax + Internal + 204; + int ParsingErrorNoSuggestion = Syntax + Internal + 205; + int InvalidUnaryExpression = Syntax + Internal + 206; + + // syntax errors + int InterfaceCannotHaveConstructors = Syntax + Internal + 207; + int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208; + int ParsingErrorOnKeyword = Syntax + Internal + 209; + int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210; + + int UnmatchedBracket = Syntax + Internal + 220; + int NoFieldOnBaseType = FieldRelated + 221; + int InvalidExpressionAsStatement = Syntax + Internal + 222; + /** @since 2.1 */ + int ExpressionShouldBeAVariable = Syntax + Internal + 223; + /** @since 2.1 */ + int MissingSemiColon = Syntax + Internal + 224; + /** @since 2.1 */ + int InvalidParenthesizedExpression = Syntax + Internal + 225; + + /** @since 3.0 */ + int ParsingErrorInsertTokenBefore = Syntax + Internal + 230; + /** @since 3.0 */ + int ParsingErrorInsertTokenAfter = Syntax + Internal + 231; + /** @since 3.0 */ + int ParsingErrorDeleteToken = Syntax + Internal + 232; + /** @since 3.0 */ + int ParsingErrorDeleteTokens = Syntax + Internal + 233; + /** @since 3.0 */ + int ParsingErrorMergeTokens = Syntax + Internal + 234; + /** @since 3.0 */ + int ParsingErrorInvalidToken = Syntax + Internal + 235; + /** @since 3.0 */ + int ParsingErrorMisplacedConstruct = Syntax + Internal + 236; + /** @since 3.0 */ + int ParsingErrorReplaceTokens = Syntax + Internal + 237; + /** @since 3.0 */ + int ParsingErrorNoSuggestionForTokens = Syntax + Internal + 238; + /** @since 3.0 */ + int ParsingErrorUnexpectedEOF = Syntax + Internal + 239; + /** @since 3.0 */ + int ParsingErrorInsertToComplete = Syntax + Internal + 240; + /** @since 3.0 */ + int ParsingErrorInsertToCompleteScope = Syntax + Internal + 241; + /** @since 3.0 */ + int ParsingErrorInsertToCompletePhrase = Syntax + Internal + 242; + + // scanner errors + int EndOfSource = Syntax + Internal + 250; + int InvalidHexa = Syntax + Internal + 251; + int InvalidOctal = Syntax + Internal + 252; + int InvalidCharacterConstant = Syntax + Internal + 253; + int InvalidEscape = Syntax + Internal + 254; + int InvalidInput = Syntax + Internal + 255; + int InvalidUnicodeEscape = Syntax + Internal + 256; + int InvalidFloat = Syntax + Internal + 257; + int NullSourceString = Syntax + Internal + 258; + int UnterminatedString = Syntax + Internal + 259; + int UnterminatedComment = Syntax + Internal + 260; + + // type related problems + int InterfaceCannotHaveInitializers = TypeRelated + 300; + int DuplicateModifierForType = TypeRelated + 301; + int IllegalModifierForClass = TypeRelated + 302; + int IllegalModifierForInterface = TypeRelated + 303; + int IllegalModifierForMemberClass = TypeRelated + 304; + int IllegalModifierForMemberInterface = TypeRelated + 305; + int IllegalModifierForLocalClass = TypeRelated + 306; + + int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308; + int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309; + int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310; + int IllegalStaticModifierForMemberType = TypeRelated + 311; + int SuperclassMustBeAClass = TypeRelated + 312; + int ClassExtendFinalClass = TypeRelated + 313; + int DuplicateSuperInterface = TypeRelated + 314; + int SuperInterfaceMustBeAnInterface = TypeRelated + 315; + int HierarchyCircularitySelfReference = TypeRelated + 316; + int HierarchyCircularity = TypeRelated + 317; + int HidingEnclosingType = TypeRelated + 318; + int DuplicateNestedType = TypeRelated + 319; + int CannotThrowType = TypeRelated + 320; + int PackageCollidesWithType = TypeRelated + 321; + int TypeCollidesWithPackage = TypeRelated + 322; + int DuplicateTypes = TypeRelated + 323; + int IsClassPathCorrect = TypeRelated + 324; + int PublicClassMustMatchFileName = TypeRelated + 325; + int MustSpecifyPackage = 326; + int HierarchyHasProblems = TypeRelated + 327; + int PackageIsNotExpectedPackage = 328; + /** @since 2.1 */ + int ObjectCannotHaveSuperTypes = 329; + + // int InvalidSuperclassBase = TypeRelated + 329; // reserved to 334 included + int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330 + int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331 + int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332 + int SuperclassInternalNameProvided = TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333 + int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334 + + // int InvalidInterfaceBase = TypeRelated + 334; // reserved to 339 included + int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335 + int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336 + int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337 + int InterfaceInternalNameProvided = TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338 + int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339 + + // field related problems + int DuplicateField = FieldRelated + 340; + int DuplicateModifierForField = FieldRelated + 341; + int IllegalModifierForField = FieldRelated + 342; + int IllegalModifierForInterfaceField = FieldRelated + 343; + int IllegalVisibilityModifierCombinationForField = FieldRelated + 344; + int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345; + int UnexpectedStaticModifierForField = FieldRelated + 346; + + // int FieldTypeProblemBase = FieldRelated + 349; //reserved to 354 + int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350 + int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351 + int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352 + int FieldTypeInternalNameProvided = FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353 + int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349 + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354 + + // method related problems + int DuplicateMethod = MethodRelated + 355; + int IllegalModifierForArgument = MethodRelated + 356; + int DuplicateModifierForMethod = MethodRelated + 357; + int IllegalModifierForMethod = MethodRelated + 358; + int IllegalModifierForInterfaceMethod = MethodRelated + 359; + int IllegalVisibilityModifierCombinationForMethod = MethodRelated + 360; + int UnexpectedStaticModifierForMethod = MethodRelated + 361; + int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362; + int AbstractMethodInAbstractClass = MethodRelated + 363; + int ArgumentTypeCannotBeVoid = MethodRelated + 364; + int ArgumentTypeCannotBeVoidArray = MethodRelated + 365; + int ReturnTypeCannotBeVoidArray = MethodRelated + 366; + int NativeMethodsCannotBeStrictfp = MethodRelated + 367; + int DuplicateModifierForArgument = MethodRelated + 368; + + // int ArgumentProblemBase = MethodRelated + 369; // reserved to 374 included. + int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370 + int ArgumentTypeNotVisible = MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371 + int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372 + int ArgumentTypeInternalNameProvided = MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373 + int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374 + + // int ExceptionTypeProblemBase = MethodRelated + 374; // reserved to 379 included. + int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375 + int ExceptionTypeNotVisible = MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376 + int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377 + int ExceptionTypeInternalNameProvided = MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378 + int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379 + + // int ReturnTypeProblemBase = MethodRelated + 379; + int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380 + int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381 + int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382 + int ReturnTypeInternalNameProvided = MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383 + int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384 + + // import related problems + int ConflictingImport = ImportRelated + 385; + int DuplicateImport = ImportRelated + 386; + int CannotImportPackage = ImportRelated + 387; + int UnusedImport = ImportRelated + 388; + + // int ImportProblemBase = ImportRelated + 389; + int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390 + int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391 + int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392 + int ImportInternalNameProvided = ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393 + int ImportInheritedNameHidesEnclosingName = ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394 + + // local variable related problems + int DuplicateModifierForVariable = MethodRelated + 395; + int IllegalModifierForVariable = MethodRelated + 396; + + // method verifier problems + int AbstractMethodMustBeImplemented = MethodRelated + 400; + int FinalMethodCannotBeOverridden = MethodRelated + 401; + int IncompatibleExceptionInThrowsClause = MethodRelated + 402; + int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403; + int IncompatibleReturnType = MethodRelated + 404; + int InheritedMethodReducesVisibility = MethodRelated + 405; + int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406; + int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407; + int StaticInheritedMethodConflicts = MethodRelated + 408; + int MethodReducesVisibility = MethodRelated + 409; + int OverridingNonVisibleMethod = MethodRelated + 410; + int AbstractMethodCannotBeOverridden = MethodRelated + 411; + int OverridingDeprecatedMethod = MethodRelated + 412; + /** @since 2.1 */ + int IncompatibleReturnTypeForNonInheritedInterfaceMethod = MethodRelated + 413; + /** @since 2.1 */ + int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod = MethodRelated + 414; + + // code snippet support + int CodeSnippetMissingClass = Internal + 420; + int CodeSnippetMissingMethod = Internal + 421; + int NonExternalizedStringLiteral = Internal + 261; + int CannotUseSuperInCodeSnippet = Internal + 422; + + //constant pool + int TooManyConstantsInConstantPool = Internal + 430; + /** @since 2.1 */ + int TooManyBytesForStringConstant = Internal + 431; + + // static constraints + /** @since 2.1 */ + int TooManyFields = Internal + 432; + /** @since 2.1 */ + int TooManyMethods = Internal + 433; + + // 1.4 features + // assertion warning + int UseAssertAsAnIdentifier = Internal + 440; + + // detected task + /** @since 2.1 */ + int Task = Internal + 450; + + // block + /** @since 3.0 */ + int UndocumentedEmptyBlock = Internal + 460; + + /* + * Javadoc comments + */ + /** @since 3.0 */ + int JavadocUnexpectedTag = Javadoc + Internal + 470; + /** @since 3.0 */ + int JavadocMissingParamTag = Javadoc + Internal + 471; + /** @since 3.0 */ + int JavadocMissingParamName = Javadoc + Internal + 472; + /** @since 3.0 */ + int JavadocDuplicateParamName = Javadoc + Internal + 473; + /** @since 3.0 */ + int JavadocInvalidParamName = Javadoc + Internal + 474; + /** @since 3.0 */ + int JavadocMissingReturnTag = Javadoc + Internal + 475; + /** @since 3.0 */ + int JavadocDuplicateReturnTag = Javadoc + Internal + 476; + /** @since 3.0 */ + int JavadocMissingThrowsTag = Javadoc + Internal + 477; + /** @since 3.0 */ + int JavadocMissingThrowsClassName = Javadoc + Internal + 478; + /** @since 3.0 */ + int JavadocInvalidThrowsClass = Javadoc + Internal + 479; + /** @since 3.0 */ + int JavadocDuplicateThrowsClassName = Javadoc + Internal + 480; + /** @since 3.0 */ + int JavadocInvalidThrowsClassName = Javadoc + Internal + 481; + /** @since 3.0 */ + int JavadocMissingSeeReference = Javadoc + Internal + 482; + /** @since 3.0 */ + int JavadocInvalidSeeReference = Javadoc + Internal + 483; + /** @since 3.0 */ + int JavadocInvalidSeeHref = Javadoc + Internal + 484; + /** @since 3.0 */ + int JavadocInvalidSeeArgs = Javadoc + Internal + 485; + /** @since 3.0 */ + int JavadocMissing = Javadoc + Internal + 486; + /** @since 3.0 */ + int JavadocInvalidTag = Javadoc + Internal + 487; + /* + * ID for field errors in Javadoc + */ + /** @since 3.0 */ + int JavadocUndefinedField = Javadoc + Internal + 488; + /** @since 3.0 */ + int JavadocNotVisibleField = Javadoc + Internal + 489; + /** @since 3.0 */ + int JavadocAmbiguousField = Javadoc + Internal + 490; + /** @since 3.0 */ + int JavadocUsingDeprecatedField = Javadoc + Internal + 491; + /* + * IDs for constructor errors in Javadoc + */ + /** @since 3.0 */ + int JavadocUndefinedConstructor = Javadoc + Internal + 492; + /** @since 3.0 */ + int JavadocNotVisibleConstructor = Javadoc + Internal + 493; + /** @since 3.0 */ + int JavadocAmbiguousConstructor = Javadoc + Internal + 494; + /** @since 3.0 */ + int JavadocUsingDeprecatedConstructor = Javadoc + Internal + 495; + /* + * IDs for method errors in Javadoc + */ + /** @since 3.0 */ + int JavadocUndefinedMethod = Javadoc + Internal + 496; + /** @since 3.0 */ + int JavadocNotVisibleMethod = Javadoc + Internal + 497; + /** @since 3.0 */ + int JavadocAmbiguousMethod = Javadoc + Internal + 498; + /** @since 3.0 */ + int JavadocUsingDeprecatedMethod = Javadoc + Internal + 499; + /** @since 3.0 */ + int JavadocNoMessageSendOnBaseType = Javadoc + Internal + 500; + /** @since 3.0 */ + int JavadocParameterMismatch = Javadoc + Internal + 501; + /** @since 3.0 */ + int JavadocNoMessageSendOnArrayType = Javadoc + Internal + 502; + /* + * IDs for type errors in Javadoc + */ + /** @since 3.0 */ + int JavadocUndefinedType = Javadoc + Internal + 503; + /** @since 3.0 */ + int JavadocNotVisibleType = Javadoc + Internal + 504; + /** @since 3.0 */ + int JavadocAmbiguousType = Javadoc + Internal + 505; + /** @since 3.0 */ + int JavadocUsingDeprecatedType = Javadoc + Internal + 506; + /** @since 3.0 */ + int JavadocInternalTypeNameProvided = Javadoc + Internal + 507; + /** @since 3.0 */ + int JavadocInheritedMethodHidesEnclosingName = Javadoc + Internal + 508; + /** @since 3.0 */ + int JavadocInheritedFieldHidesEnclosingName = Javadoc + Internal + 509; + /** @since 3.0 */ + int JavadocInheritedNameHidesEnclosingTypeName = Javadoc + Internal + 510; + /** @since 3.0 */ + int JavadocAmbiguousMethodReference = Javadoc + Internal + 511; + /** @since 3.0 */ + int JavadocUnterminatedInlineTag = Javadoc + Internal + 512; + /** @since 3.0 */ + int JavadocMalformedSeeReference = Javadoc + Internal + 513; + /** @since 3.0 */ + int JavadocMessagePrefix = Internal + 515; +}