0001: /*******************************************************************************
0002: * Copyright (c) 2000, 2007 IBM Corporation and others.
0003: * All rights reserved. This program and the accompanying materials
0004: * are made available under the terms of the Eclipse Public License v1.0
0005: * which accompanies this distribution, and is available at
0006: * http://www.eclipse.org/legal/epl-v10.html
0007: *
0008: * Contributors:
0009: * IBM Corporation - initial API and implementation
0010: * IBM Corporation - added the following constants
0011: * NonStaticAccessToStaticField
0012: * NonStaticAccessToStaticMethod
0013: * Task
0014: * ExpressionShouldBeAVariable
0015: * AssignmentHasNoEffect
0016: * IBM Corporation - added the following constants
0017: * TooManySyntheticArgumentSlots
0018: * TooManyArrayDimensions
0019: * TooManyBytesForStringConstant
0020: * TooManyMethods
0021: * TooManyFields
0022: * NonBlankFinalLocalAssignment
0023: * ObjectCannotHaveSuperTypes
0024: * MissingSemiColon
0025: * InvalidParenthesizedExpression
0026: * EnclosingInstanceInConstructorCall
0027: * BytecodeExceeds64KLimitForConstructor
0028: * IncompatibleReturnTypeForNonInheritedInterfaceMethod
0029: * UnusedPrivateMethod
0030: * UnusedPrivateConstructor
0031: * UnusedPrivateType
0032: * UnusedPrivateField
0033: * IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
0034: * InvalidExplicitConstructorCall
0035: * IBM Corporation - added the following constants
0036: * PossibleAccidentalBooleanAssignment
0037: * SuperfluousSemicolon
0038: * IndirectAccessToStaticField
0039: * IndirectAccessToStaticMethod
0040: * IndirectAccessToStaticType
0041: * BooleanMethodThrowingException
0042: * UnnecessaryCast
0043: * UnnecessaryArgumentCast
0044: * UnnecessaryInstanceof
0045: * FinallyMustCompleteNormally
0046: * UnusedMethodDeclaredThrownException
0047: * UnusedConstructorDeclaredThrownException
0048: * InvalidCatchBlockSequence
0049: * UnqualifiedFieldAccess
0050: * IBM Corporation - added the following constants
0051: * Javadoc
0052: * JavadocUnexpectedTag
0053: * JavadocMissingParamTag
0054: * JavadocMissingParamName
0055: * JavadocDuplicateParamName
0056: * JavadocInvalidParamName
0057: * JavadocMissingReturnTag
0058: * JavadocDuplicateReturnTag
0059: * JavadocMissingThrowsTag
0060: * JavadocMissingThrowsClassName
0061: * JavadocInvalidThrowsClass
0062: * JavadocDuplicateThrowsClassName
0063: * JavadocInvalidThrowsClassName
0064: * JavadocMissingSeeReference
0065: * JavadocInvalidSeeReference
0066: * JavadocInvalidSeeHref
0067: * JavadocInvalidSeeArgs
0068: * JavadocMissing
0069: * JavadocInvalidTag
0070: * JavadocMessagePrefix
0071: * EmptyControlFlowStatement
0072: * IBM Corporation - added the following constants
0073: * IllegalUsageOfQualifiedTypeReference
0074: * InvalidDigit
0075: * IBM Corporation - added the following constants
0076: * ParameterAssignment
0077: * FallthroughCase
0078: * IBM Corporation - added the following constants
0079: * UnusedLabel
0080: * UnnecessaryNLSTag
0081: * LocalVariableMayBeNull
0082: * EnumConstantsCannotBeSurroundedByParenthesis
0083: * JavadocMissingIdentifier
0084: * JavadocNonStaticTypeFromStaticInvocation
0085: * RawTypeReference
0086: * NoAdditionalBoundAfterTypeVariable
0087: * UnsafeGenericArrayForVarargs
0088: * IllegalAccessFromTypeVariable
0089: * AnnotationValueMustBeArrayInitializer
0090: * InvalidEncoding
0091: * CannotReadSource
0092: * EnumStaticFieldInInInitializerContext
0093: * ExternalProblemNotFixable
0094: * ExternalProblemFixable
0095: * IBM Corporation - added the following constants
0096: * AnnotationValueMustBeAnEnumConstant
0097: * OverridingMethodWithoutSuperInvocation
0098: * MethodMustOverrideOrImplement
0099: * TypeHidingTypeParameterFromType
0100: * TypeHidingTypeParameterFromMethod
0101: * TypeHidingType
0102: * IBM Corporation - added the following constants
0103: * NullLocalVariableReference
0104: * PotentialNullLocalVariableReference
0105: * RedundantNullCheckOnNullLocalVariable
0106: * NullLocalVariableComparisonYieldsFalse
0107: * RedundantLocalVariableNullAssignment
0108: * NullLocalVariableInstanceofYieldsFalse
0109: * RedundantNullCheckOnNonNullLocalVariable
0110: * NonNullLocalVariableComparisonYieldsFalse
0111: * IBM Corporation - added the following constants
0112: * InvalidUsageOfTypeParametersForAnnotationDeclaration
0113: * InvalidUsageOfTypeParametersForEnumDeclaration
0114: *******************************************************************************/package org.eclipse.jdt.core.compiler;
0115:
0116: import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
0117:
0118: /**
0119: * Description of a Java problem, as detected by the compiler or some of the underlying
0120: * technology reusing the compiler.
0121: * A problem provides access to:
0122: * <ul>
0123: * <li> its location (originating source file name, source position, line number), </li>
0124: * <li> its message description and a predicate to check its severity (warning or error). </li>
0125: * <li> its ID : a number identifying the very nature of this problem. All possible IDs are listed
0126: * as constants on this interface. </li>
0127: * </ul>
0128: *
0129: * Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder
0130: * so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected
0131: * when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular
0132: * their ID (attribute "id") is set to one of the IDs defined on this interface.
0133: *
0134: * @since 2.0
0135: */
0136: public interface IProblem {
0137:
0138: /**
0139: * Answer back the original arguments recorded into the problem.
0140: * @return the original arguments recorded into the problem
0141: */
0142: String[] getArguments();
0143:
0144: /**
0145: * Returns the problem id
0146: *
0147: * @return the problem id
0148: */
0149: int getID();
0150:
0151: /**
0152: * Answer a localized, human-readable message string which describes the problem.
0153: *
0154: * @return a localized, human-readable message string which describes the problem
0155: */
0156: String getMessage();
0157:
0158: /**
0159: * Answer the file name in which the problem was found.
0160: *
0161: * @return the file name in which the problem was found
0162: */
0163: char[] getOriginatingFileName();
0164:
0165: /**
0166: * Answer the end position of the problem (inclusive), or -1 if unknown.
0167: *
0168: * @return the end position of the problem (inclusive), or -1 if unknown
0169: */
0170: int getSourceEnd();
0171:
0172: /**
0173: * Answer the line number in source where the problem begins.
0174: *
0175: * @return the line number in source where the problem begins
0176: */
0177: int getSourceLineNumber();
0178:
0179: /**
0180: * Answer the start position of the problem (inclusive), or -1 if unknown.
0181: *
0182: * @return the start position of the problem (inclusive), or -1 if unknown
0183: */
0184: int getSourceStart();
0185:
0186: /**
0187: * Checks the severity to see if the Error bit is set.
0188: *
0189: * @return true if the Error bit is set for the severity, false otherwise
0190: */
0191: boolean isError();
0192:
0193: /**
0194: * Checks the severity to see if the Error bit is not set.
0195: *
0196: * @return true if the Error bit is not set for the severity, false otherwise
0197: */
0198: boolean isWarning();
0199:
0200: /**
0201: * Set the end position of the problem (inclusive), or -1 if unknown.
0202: * Used for shifting problem positions.
0203: *
0204: * @param sourceEnd the given end position
0205: */
0206: void setSourceEnd(int sourceEnd);
0207:
0208: /**
0209: * Set the line number in source where the problem begins.
0210: *
0211: * @param lineNumber the given line number
0212: */
0213: void setSourceLineNumber(int lineNumber);
0214:
0215: /**
0216: * Set the start position of the problem (inclusive), or -1 if unknown.
0217: * Used for shifting problem positions.
0218: *
0219: * @param sourceStart the given start position
0220: */
0221: void setSourceStart(int sourceStart);
0222:
0223: /**
0224: * Problem Categories
0225: * The high bits of a problem ID contains information about the category of a problem.
0226: * For example, (problemID & TypeRelated) != 0, indicates that this problem is type related.
0227: *
0228: * A problem category can help to implement custom problem filters. Indeed, when numerous problems
0229: * are listed, focusing on import related problems first might be relevant.
0230: *
0231: * When a problem is tagged as Internal, it means that no change other than a local source code change
0232: * can fix the corresponding problem. A type related problem could be addressed by changing the type
0233: * involved in it.
0234: */
0235: int TypeRelated = 0x01000000;
0236: int FieldRelated = 0x02000000;
0237: int MethodRelated = 0x04000000;
0238: int ConstructorRelated = 0x08000000;
0239: int ImportRelated = 0x10000000;
0240: int Internal = 0x20000000;
0241: int Syntax = 0x40000000;
0242: /** @since 3.0 */
0243: int Javadoc = 0x80000000;
0244:
0245: /**
0246: * Mask to use in order to filter out the category portion of the problem ID.
0247: */
0248: int IgnoreCategoriesMask = 0xFFFFFF;
0249:
0250: /**
0251: * Below are listed all available problem IDs. Note that this list could be augmented in the future,
0252: * as new features are added to the Java core implementation.
0253: */
0254:
0255: /**
0256: * ID reserved for referencing an internal error inside the JavaCore implementation which
0257: * may be surfaced as a problem associated with the compilation unit which caused it to occur.
0258: */
0259: int Unclassified = 0;
0260:
0261: /**
0262: * General type related problems
0263: */
0264: int ObjectHasNoSuperclass = TypeRelated + 1;
0265: int UndefinedType = TypeRelated + 2;
0266: int NotVisibleType = TypeRelated + 3;
0267: int AmbiguousType = TypeRelated + 4;
0268: int UsingDeprecatedType = TypeRelated + 5;
0269: int InternalTypeNameProvided = TypeRelated + 6;
0270: /** @since 2.1 */
0271: int UnusedPrivateType = Internal + TypeRelated + 7;
0272:
0273: int IncompatibleTypesInEqualityOperator = TypeRelated + 15;
0274: int IncompatibleTypesInConditionalOperator = TypeRelated + 16;
0275: int TypeMismatch = TypeRelated + 17;
0276: /** @since 3.0 */
0277: int IndirectAccessToStaticType = Internal + TypeRelated + 18;
0278:
0279: /**
0280: * Inner types related problems
0281: */
0282: int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
0283: int MissingEnclosingInstance = TypeRelated + 21;
0284: int IncorrectEnclosingInstanceReference = TypeRelated + 22;
0285: int IllegalEnclosingInstanceSpecification = TypeRelated + 23;
0286: int CannotDefineStaticInitializerInLocalType = Internal + 24;
0287: int OuterLocalMustBeFinal = Internal + 25;
0288: int CannotDefineInterfaceInLocalType = Internal + 26;
0289: int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27;
0290: /** @since 2.1 */
0291: int EnclosingInstanceInConstructorCall = Internal + 28;
0292: int AnonymousClassCannotExtendFinalClass = TypeRelated + 29;
0293: /** @since 3.1 */
0294: int CannotDefineAnnotationInLocalType = Internal + 30;
0295: /** @since 3.1 */
0296: int CannotDefineEnumInLocalType = Internal + 31;
0297: /** @since 3.1 */
0298: int NonStaticContextForEnumMemberType = Internal + 32;
0299: /** @since 3.3 */
0300: int TypeHidingType = TypeRelated + 33;
0301:
0302: // variables
0303: int UndefinedName = Internal + FieldRelated + 50;
0304: int UninitializedLocalVariable = Internal + 51;
0305: int VariableTypeCannotBeVoid = Internal + 52;
0306: /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
0307: int VariableTypeCannotBeVoidArray = Internal + 53;
0308: int CannotAllocateVoidArray = Internal + 54;
0309: // local variables
0310: int RedefinedLocal = Internal + 55;
0311: int RedefinedArgument = Internal + 56;
0312: // final local variables
0313: int DuplicateFinalLocalInitialization = Internal + 57;
0314: /** @since 2.1 */
0315: int NonBlankFinalLocalAssignment = Internal + 58;
0316: /** @since 3.2 */
0317: int ParameterAssignment = Internal + 59;
0318: int FinalOuterLocalAssignment = Internal + 60;
0319: int LocalVariableIsNeverUsed = Internal + 61;
0320: int ArgumentIsNeverUsed = Internal + 62;
0321: int BytecodeExceeds64KLimit = Internal + 63;
0322: int BytecodeExceeds64KLimitForClinit = Internal + 64;
0323: int TooManyArgumentSlots = Internal + 65;
0324: int TooManyLocalVariableSlots = Internal + 66;
0325: /** @since 2.1 */
0326: int TooManySyntheticArgumentSlots = Internal + 67;
0327: /** @since 2.1 */
0328: int TooManyArrayDimensions = Internal + 68;
0329: /** @since 2.1 */
0330: int BytecodeExceeds64KLimitForConstructor = Internal + 69;
0331:
0332: // fields
0333: int UndefinedField = FieldRelated + 70;
0334: int NotVisibleField = FieldRelated + 71;
0335: int AmbiguousField = FieldRelated + 72;
0336: int UsingDeprecatedField = FieldRelated + 73;
0337: int NonStaticFieldFromStaticInvocation = FieldRelated + 74;
0338: int ReferenceToForwardField = FieldRelated + Internal + 75;
0339: /** @since 2.1 */
0340: int NonStaticAccessToStaticField = Internal + FieldRelated + 76;
0341: /** @since 2.1 */
0342: int UnusedPrivateField = Internal + FieldRelated + 77;
0343: /** @since 3.0 */
0344: int IndirectAccessToStaticField = Internal + FieldRelated + 78;
0345: /** @since 3.0 */
0346: int UnqualifiedFieldAccess = Internal + FieldRelated + 79;
0347:
0348: // blank final fields
0349: int FinalFieldAssignment = FieldRelated + 80;
0350: int UninitializedBlankFinalField = FieldRelated + 81;
0351: int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
0352:
0353: // variable hiding
0354: /** @since 3.0 */
0355: int LocalVariableHidingLocalVariable = Internal + 90;
0356: /** @since 3.0 */
0357: int LocalVariableHidingField = Internal + FieldRelated + 91;
0358: /** @since 3.0 */
0359: int FieldHidingLocalVariable = Internal + FieldRelated + 92;
0360: /** @since 3.0 */
0361: int FieldHidingField = Internal + FieldRelated + 93;
0362: /** @since 3.0 */
0363: int ArgumentHidingLocalVariable = Internal + 94;
0364: /** @since 3.0 */
0365: int ArgumentHidingField = Internal + 95;
0366: /** @since 3.1 */
0367: int MissingSerialVersion = Internal + 96;
0368:
0369: // methods
0370: int UndefinedMethod = MethodRelated + 100;
0371: int NotVisibleMethod = MethodRelated + 101;
0372: int AmbiguousMethod = MethodRelated + 102;
0373: int UsingDeprecatedMethod = MethodRelated + 103;
0374: int DirectInvocationOfAbstractMethod = MethodRelated + 104;
0375: int VoidMethodReturnsValue = MethodRelated + 105;
0376: int MethodReturnsVoid = MethodRelated + 106;
0377: int MethodRequiresBody = Internal + MethodRelated + 107;
0378: int ShouldReturnValue = Internal + MethodRelated + 108;
0379: int MethodButWithConstructorName = MethodRelated + 110;
0380: int MissingReturnType = TypeRelated + 111;
0381: int BodyForNativeMethod = Internal + MethodRelated + 112;
0382: int BodyForAbstractMethod = Internal + MethodRelated + 113;
0383: int NoMessageSendOnBaseType = MethodRelated + 114;
0384: int ParameterMismatch = MethodRelated + 115;
0385: int NoMessageSendOnArrayType = MethodRelated + 116;
0386: /** @since 2.1 */
0387: int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117;
0388: /** @since 2.1 */
0389: int UnusedPrivateMethod = Internal + MethodRelated + 118;
0390: /** @since 3.0 */
0391: int IndirectAccessToStaticMethod = Internal + MethodRelated + 119;
0392:
0393: // constructors
0394: int UndefinedConstructor = ConstructorRelated + 130;
0395: int NotVisibleConstructor = ConstructorRelated + 131;
0396: int AmbiguousConstructor = ConstructorRelated + 132;
0397: int UsingDeprecatedConstructor = ConstructorRelated + 133;
0398: /** @since 2.1 */
0399: int UnusedPrivateConstructor = Internal + MethodRelated + 134;
0400: // explicit constructor calls
0401: int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135;
0402: int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136;
0403: int RecursiveConstructorInvocation = ConstructorRelated + 137;
0404: int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138;
0405: /** @since 3.0 */
0406: int InvalidExplicitConstructorCall = ConstructorRelated + Syntax
0407: + 139;
0408: // implicit constructor calls
0409: int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140;
0410: int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141;
0411: int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142;
0412: int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143;
0413: int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144;
0414: int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145;
0415: int UnhandledExceptionInDefaultConstructor = TypeRelated + 146;
0416: int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147;
0417:
0418: // expressions
0419: int ArrayReferenceRequired = Internal + 150;
0420: int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
0421: // constant expressions
0422: int StringConstantIsExceedingUtf8Limit = Internal + 152;
0423: int NonConstantExpression = Internal + 153;
0424: int NumericValueOutOfRange = Internal + 154;
0425: // cast expressions
0426: int IllegalCast = TypeRelated + 156;
0427: // allocations
0428: int InvalidClassInstantiation = TypeRelated + 157;
0429: int CannotDefineDimensionExpressionsWithInit = Internal + 158;
0430: int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159;
0431: // operators
0432: int InvalidOperator = Internal + 160;
0433: // statements
0434: int CodeCannotBeReached = Internal + 161;
0435: int CannotReturnInInitializer = Internal + 162;
0436: int InitializerMustCompleteNormally = Internal + 163;
0437: // assert
0438: int InvalidVoidExpression = Internal + 164;
0439: // try
0440: int MaskedCatch = TypeRelated + 165;
0441: int DuplicateDefaultCase = Internal + 166;
0442: int UnreachableCatch = TypeRelated + MethodRelated + 167;
0443: int UnhandledException = TypeRelated + 168;
0444: // switch
0445: int IncorrectSwitchType = TypeRelated + 169;
0446: int DuplicateCase = FieldRelated + 170;
0447:
0448: // labelled
0449: int DuplicateLabel = Internal + 171;
0450: int InvalidBreak = Internal + 172;
0451: int InvalidContinue = Internal + 173;
0452: int UndefinedLabel = Internal + 174;
0453: //synchronized
0454: int InvalidTypeToSynchronized = Internal + 175;
0455: int InvalidNullToSynchronized = Internal + 176;
0456: // throw
0457: int CannotThrowNull = Internal + 177;
0458: // assignment
0459: /** @since 2.1 */
0460: int AssignmentHasNoEffect = Internal + 178;
0461: /** @since 3.0 */
0462: int PossibleAccidentalBooleanAssignment = Internal + 179;
0463: /** @since 3.0 */
0464: int SuperfluousSemicolon = Internal + 180;
0465: /** @since 3.0 */
0466: int UnnecessaryCast = Internal + TypeRelated + 181;
0467: /** @deprecated - no longer generated, use {@link #UnnecessaryCast} instead
0468: * @since 3.0 */
0469: int UnnecessaryArgumentCast = Internal + TypeRelated + 182;
0470: /** @since 3.0 */
0471: int UnnecessaryInstanceof = Internal + TypeRelated + 183;
0472: /** @since 3.0 */
0473: int FinallyMustCompleteNormally = Internal + 184;
0474: /** @since 3.0 */
0475: int UnusedMethodDeclaredThrownException = Internal + 185;
0476: /** @since 3.0 */
0477: int UnusedConstructorDeclaredThrownException = Internal + 186;
0478: /** @since 3.0 */
0479: int InvalidCatchBlockSequence = Internal + TypeRelated + 187;
0480: /** @since 3.0 */
0481: int EmptyControlFlowStatement = Internal + TypeRelated + 188;
0482: /** @since 3.0 */
0483: int UnnecessaryElse = Internal + 189;
0484:
0485: // inner emulation
0486: int NeedToEmulateFieldReadAccess = FieldRelated + 190;
0487: int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
0488: int NeedToEmulateMethodAccess = MethodRelated + 192;
0489: int NeedToEmulateConstructorAccess = MethodRelated + 193;
0490:
0491: /** @since 3.2 */
0492: int FallthroughCase = Internal + 194;
0493:
0494: //inherited name hides enclosing name (sort of ambiguous)
0495: int InheritedMethodHidesEnclosingName = MethodRelated + 195;
0496: int InheritedFieldHidesEnclosingName = FieldRelated + 196;
0497: int InheritedTypeHidesEnclosingName = TypeRelated + 197;
0498:
0499: /** @since 3.1 */
0500: int IllegalUsageOfQualifiedTypeReference = Internal + Syntax + 198;
0501:
0502: // miscellaneous
0503: /** @since 3.2 */
0504: int UnusedLabel = Internal + 199;
0505: int ThisInStaticContext = Internal + 200;
0506: int StaticMethodRequested = Internal + MethodRelated + 201;
0507: int IllegalDimension = Internal + 202;
0508: int InvalidTypeExpression = Internal + 203;
0509: int ParsingError = Syntax + Internal + 204;
0510: int ParsingErrorNoSuggestion = Syntax + Internal + 205;
0511: int InvalidUnaryExpression = Syntax + Internal + 206;
0512:
0513: // syntax errors
0514: int InterfaceCannotHaveConstructors = Syntax + Internal + 207;
0515: int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208;
0516: int ParsingErrorOnKeyword = Syntax + Internal + 209;
0517: int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;
0518:
0519: int UnmatchedBracket = Syntax + Internal + 220;
0520: int NoFieldOnBaseType = FieldRelated + 221;
0521: int InvalidExpressionAsStatement = Syntax + Internal + 222;
0522: /** @since 2.1 */
0523: int ExpressionShouldBeAVariable = Syntax + Internal + 223;
0524: /** @since 2.1 */
0525: int MissingSemiColon = Syntax + Internal + 224;
0526: /** @since 2.1 */
0527: int InvalidParenthesizedExpression = Syntax + Internal + 225;
0528:
0529: /** @since 3.0 */
0530: int ParsingErrorInsertTokenBefore = Syntax + Internal + 230;
0531: /** @since 3.0 */
0532: int ParsingErrorInsertTokenAfter = Syntax + Internal + 231;
0533: /** @since 3.0 */
0534: int ParsingErrorDeleteToken = Syntax + Internal + 232;
0535: /** @since 3.0 */
0536: int ParsingErrorDeleteTokens = Syntax + Internal + 233;
0537: /** @since 3.0 */
0538: int ParsingErrorMergeTokens = Syntax + Internal + 234;
0539: /** @since 3.0 */
0540: int ParsingErrorInvalidToken = Syntax + Internal + 235;
0541: /** @since 3.0 */
0542: int ParsingErrorMisplacedConstruct = Syntax + Internal + 236;
0543: /** @since 3.0 */
0544: int ParsingErrorReplaceTokens = Syntax + Internal + 237;
0545: /** @since 3.0 */
0546: int ParsingErrorNoSuggestionForTokens = Syntax + Internal + 238;
0547: /** @since 3.0 */
0548: int ParsingErrorUnexpectedEOF = Syntax + Internal + 239;
0549: /** @since 3.0 */
0550: int ParsingErrorInsertToComplete = Syntax + Internal + 240;
0551: /** @since 3.0 */
0552: int ParsingErrorInsertToCompleteScope = Syntax + Internal + 241;
0553: /** @since 3.0 */
0554: int ParsingErrorInsertToCompletePhrase = Syntax + Internal + 242;
0555:
0556: // scanner errors
0557: int EndOfSource = Syntax + Internal + 250;
0558: int InvalidHexa = Syntax + Internal + 251;
0559: int InvalidOctal = Syntax + Internal + 252;
0560: int InvalidCharacterConstant = Syntax + Internal + 253;
0561: int InvalidEscape = Syntax + Internal + 254;
0562: int InvalidInput = Syntax + Internal + 255;
0563: int InvalidUnicodeEscape = Syntax + Internal + 256;
0564: int InvalidFloat = Syntax + Internal + 257;
0565: int NullSourceString = Syntax + Internal + 258;
0566: int UnterminatedString = Syntax + Internal + 259;
0567: int UnterminatedComment = Syntax + Internal + 260;
0568: int NonExternalizedStringLiteral = Internal + 261;
0569: /** @since 3.1 */
0570: int InvalidDigit = Syntax + Internal + 262;
0571: /** @since 3.1 */
0572: int InvalidLowSurrogate = Syntax + Internal + 263;
0573: /** @since 3.1 */
0574: int InvalidHighSurrogate = Syntax + Internal + 264;
0575: /** @since 3.2 */
0576: int UnnecessaryNLSTag = Internal + 265;
0577:
0578: // type related problems
0579: /** @since 3.1 */
0580: int DiscouragedReference = TypeRelated + 280;
0581:
0582: int InterfaceCannotHaveInitializers = TypeRelated + 300;
0583: int DuplicateModifierForType = TypeRelated + 301;
0584: int IllegalModifierForClass = TypeRelated + 302;
0585: int IllegalModifierForInterface = TypeRelated + 303;
0586: int IllegalModifierForMemberClass = TypeRelated + 304;
0587: int IllegalModifierForMemberInterface = TypeRelated + 305;
0588: int IllegalModifierForLocalClass = TypeRelated + 306;
0589: /** @since 3.1 */
0590: int ForbiddenReference = TypeRelated + 307;
0591: int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308;
0592: int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309;
0593: int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310;
0594: int IllegalStaticModifierForMemberType = TypeRelated + 311;
0595: int SuperclassMustBeAClass = TypeRelated + 312;
0596: int ClassExtendFinalClass = TypeRelated + 313;
0597: int DuplicateSuperInterface = TypeRelated + 314;
0598: int SuperInterfaceMustBeAnInterface = TypeRelated + 315;
0599: int HierarchyCircularitySelfReference = TypeRelated + 316;
0600: int HierarchyCircularity = TypeRelated + 317;
0601: int HidingEnclosingType = TypeRelated + 318;
0602: int DuplicateNestedType = TypeRelated + 319;
0603: int CannotThrowType = TypeRelated + 320;
0604: int PackageCollidesWithType = TypeRelated + 321;
0605: int TypeCollidesWithPackage = TypeRelated + 322;
0606: int DuplicateTypes = TypeRelated + 323;
0607: int IsClassPathCorrect = TypeRelated + 324;
0608: int PublicClassMustMatchFileName = TypeRelated + 325;
0609: int MustSpecifyPackage = Internal + 326;
0610: int HierarchyHasProblems = TypeRelated + 327;
0611: int PackageIsNotExpectedPackage = Internal + 328;
0612: /** @since 2.1 */
0613: int ObjectCannotHaveSuperTypes = Internal + 329;
0614: /** @since 3.1 */
0615: int ObjectMustBeClass = Internal + 330;
0616:
0617: /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
0618: int SuperclassNotFound = TypeRelated + 329
0619: + ProblemReasons.NotFound; // TypeRelated + 330
0620: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0621: int SuperclassNotVisible = TypeRelated + 329
0622: + ProblemReasons.NotVisible; // TypeRelated + 331
0623: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0624: int SuperclassAmbiguous = TypeRelated + 329
0625: + ProblemReasons.Ambiguous; // TypeRelated + 332
0626: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0627: int SuperclassInternalNameProvided = TypeRelated + 329
0628: + ProblemReasons.InternalNameProvided; // TypeRelated + 333
0629: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0630: int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329
0631: + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
0632:
0633: /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
0634: int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
0635: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0636: int InterfaceNotVisible = TypeRelated + 334
0637: + ProblemReasons.NotVisible; // TypeRelated + 336
0638: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0639: int InterfaceAmbiguous = TypeRelated + 334
0640: + ProblemReasons.Ambiguous; // TypeRelated + 337
0641: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0642: int InterfaceInternalNameProvided = TypeRelated + 334
0643: + ProblemReasons.InternalNameProvided; // TypeRelated + 338
0644: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0645: int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334
0646: + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
0647:
0648: // field related problems
0649: int DuplicateField = FieldRelated + 340;
0650: int DuplicateModifierForField = FieldRelated + 341;
0651: int IllegalModifierForField = FieldRelated + 342;
0652: int IllegalModifierForInterfaceField = FieldRelated + 343;
0653: int IllegalVisibilityModifierCombinationForField = FieldRelated + 344;
0654: int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345;
0655: int UnexpectedStaticModifierForField = FieldRelated + 346;
0656:
0657: /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
0658: int FieldTypeNotFound = FieldRelated + 349
0659: + ProblemReasons.NotFound; // FieldRelated + 350
0660: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0661: int FieldTypeNotVisible = FieldRelated + 349
0662: + ProblemReasons.NotVisible; // FieldRelated + 351
0663: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0664: int FieldTypeAmbiguous = FieldRelated + 349
0665: + ProblemReasons.Ambiguous; // FieldRelated + 352
0666: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0667: int FieldTypeInternalNameProvided = FieldRelated + 349
0668: + ProblemReasons.InternalNameProvided; // FieldRelated + 353
0669: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0670: int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349
0671: + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354
0672:
0673: // method related problems
0674: int DuplicateMethod = MethodRelated + 355;
0675: int IllegalModifierForArgument = MethodRelated + 356;
0676: int DuplicateModifierForMethod = MethodRelated + 357;
0677: int IllegalModifierForMethod = MethodRelated + 358;
0678: int IllegalModifierForInterfaceMethod = MethodRelated + 359;
0679: int IllegalVisibilityModifierCombinationForMethod = MethodRelated + 360;
0680: int UnexpectedStaticModifierForMethod = MethodRelated + 361;
0681: int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
0682: int AbstractMethodInAbstractClass = MethodRelated + 363;
0683: int ArgumentTypeCannotBeVoid = MethodRelated + 364;
0684: /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
0685: int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
0686: /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
0687: int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
0688: int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
0689: int DuplicateModifierForArgument = MethodRelated + 368;
0690:
0691: /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
0692: int ArgumentTypeNotFound = MethodRelated + 369
0693: + ProblemReasons.NotFound; // MethodRelated + 370
0694: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0695: int ArgumentTypeNotVisible = MethodRelated + 369
0696: + ProblemReasons.NotVisible; // MethodRelated + 371
0697: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0698: int ArgumentTypeAmbiguous = MethodRelated + 369
0699: + ProblemReasons.Ambiguous; // MethodRelated + 372
0700: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0701: int ArgumentTypeInternalNameProvided = MethodRelated + 369
0702: + ProblemReasons.InternalNameProvided; // MethodRelated + 373
0703: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0704: int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated
0705: + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
0706:
0707: /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
0708: int ExceptionTypeNotFound = MethodRelated + 374
0709: + ProblemReasons.NotFound; // MethodRelated + 375
0710: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0711: int ExceptionTypeNotVisible = MethodRelated + 374
0712: + ProblemReasons.NotVisible; // MethodRelated + 376
0713: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0714: int ExceptionTypeAmbiguous = MethodRelated + 374
0715: + ProblemReasons.Ambiguous; // MethodRelated + 377
0716: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0717: int ExceptionTypeInternalNameProvided = MethodRelated + 374
0718: + ProblemReasons.InternalNameProvided; // MethodRelated + 378
0719: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0720: int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated
0721: + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
0722:
0723: /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
0724: int ReturnTypeNotFound = MethodRelated + 379
0725: + ProblemReasons.NotFound; // MethodRelated + 380
0726: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0727: int ReturnTypeNotVisible = MethodRelated + 379
0728: + ProblemReasons.NotVisible; // MethodRelated + 381
0729: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0730: int ReturnTypeAmbiguous = MethodRelated + 379
0731: + ProblemReasons.Ambiguous; // MethodRelated + 382
0732: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0733: int ReturnTypeInternalNameProvided = MethodRelated + 379
0734: + ProblemReasons.InternalNameProvided; // MethodRelated + 383
0735: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0736: int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379
0737: + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
0738:
0739: // import related problems
0740: int ConflictingImport = ImportRelated + 385;
0741: int DuplicateImport = ImportRelated + 386;
0742: int CannotImportPackage = ImportRelated + 387;
0743: int UnusedImport = ImportRelated + 388;
0744:
0745: int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
0746: /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
0747: int ImportNotVisible = ImportRelated + 389
0748: + ProblemReasons.NotVisible; // ImportRelated + 391
0749: /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
0750: int ImportAmbiguous = ImportRelated + 389
0751: + ProblemReasons.Ambiguous; // ImportRelated + 392
0752: /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
0753: int ImportInternalNameProvided = ImportRelated + 389
0754: + ProblemReasons.InternalNameProvided; // ImportRelated + 393
0755: /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
0756: int ImportInheritedNameHidesEnclosingName = ImportRelated + 389
0757: + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
0758:
0759: /** @since 3.1 */
0760: int InvalidTypeForStaticImport = ImportRelated + 391;
0761:
0762: // local variable related problems
0763: int DuplicateModifierForVariable = MethodRelated + 395;
0764: int IllegalModifierForVariable = MethodRelated + 396;
0765: /** @deprecated - problem is no longer generated, use {@link #RedundantNullCheckOnNonNullLocalVariable} instead */
0766: int LocalVariableCannotBeNull = Internal + 397; // since 3.3: semantics are LocalVariableRedundantCheckOnNonNull
0767: /** @deprecated - problem is no longer generated, use {@link #NullLocalVariableReference}, {@link #RedundantNullCheckOnNullLocalVariable} or {@link #RedundantLocalVariableNullAssignment} instead */
0768: int LocalVariableCanOnlyBeNull = Internal + 398; // since 3.3: split with LocalVariableRedundantCheckOnNull depending on context
0769: /** @deprecated - problem is no longer generated, use {@link #PotentialNullLocalVariableReference} instead */
0770: int LocalVariableMayBeNull = Internal + 399;
0771:
0772: // method verifier problems
0773: int AbstractMethodMustBeImplemented = MethodRelated + 400;
0774: int FinalMethodCannotBeOverridden = MethodRelated + 401;
0775: int IncompatibleExceptionInThrowsClause = MethodRelated + 402;
0776: int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403;
0777: int IncompatibleReturnType = MethodRelated + 404;
0778: int InheritedMethodReducesVisibility = MethodRelated + 405;
0779: int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406;
0780: int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407;
0781: int StaticInheritedMethodConflicts = MethodRelated + 408;
0782: int MethodReducesVisibility = MethodRelated + 409;
0783: int OverridingNonVisibleMethod = MethodRelated + 410;
0784: int AbstractMethodCannotBeOverridden = MethodRelated + 411;
0785: int OverridingDeprecatedMethod = MethodRelated + 412;
0786: /** @since 2.1 */
0787: int IncompatibleReturnTypeForNonInheritedInterfaceMethod = MethodRelated + 413;
0788: /** @since 2.1 */
0789: int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod = MethodRelated + 414;
0790: /** @since 3.1 */
0791: int IllegalVararg = MethodRelated + 415;
0792: /** @since 3.3 */
0793: int OverridingMethodWithoutSuperInvocation = MethodRelated + 416;
0794:
0795: // code snippet support
0796: int CodeSnippetMissingClass = Internal + 420;
0797: int CodeSnippetMissingMethod = Internal + 421;
0798: int CannotUseSuperInCodeSnippet = Internal + 422;
0799:
0800: //constant pool
0801: int TooManyConstantsInConstantPool = Internal + 430;
0802: /** @since 2.1 */
0803: int TooManyBytesForStringConstant = Internal + 431;
0804:
0805: // static constraints
0806: /** @since 2.1 */
0807: int TooManyFields = Internal + 432;
0808: /** @since 2.1 */
0809: int TooManyMethods = Internal + 433;
0810:
0811: // 1.4 features
0812: // assertion warning
0813: int UseAssertAsAnIdentifier = Internal + 440;
0814:
0815: // 1.5 features
0816: int UseEnumAsAnIdentifier = Internal + 441;
0817: /** @since 3.2 */
0818: int EnumConstantsCannotBeSurroundedByParenthesis = Syntax
0819: + Internal + 442;
0820:
0821: // detected task
0822: /** @since 2.1 */
0823: int Task = Internal + 450;
0824:
0825: // local variables related problems, cont'd
0826: /** @since 3.3 */
0827: int NullLocalVariableReference = Internal + 451;
0828: /** @since 3.3 */
0829: int PotentialNullLocalVariableReference = Internal + 452;
0830: /** @since 3.3 */
0831: int RedundantNullCheckOnNullLocalVariable = Internal + 453;
0832: /** @since 3.3 */
0833: int NullLocalVariableComparisonYieldsFalse = Internal + 454;
0834: /** @since 3.3 */
0835: int RedundantLocalVariableNullAssignment = Internal + 455;
0836: /** @since 3.3 */
0837: int NullLocalVariableInstanceofYieldsFalse = Internal + 456;
0838: /** @since 3.3 */
0839: int RedundantNullCheckOnNonNullLocalVariable = Internal + 457;
0840: /** @since 3.3 */
0841: int NonNullLocalVariableComparisonYieldsFalse = Internal + 458;
0842:
0843: // block
0844: /** @since 3.0 */
0845: int UndocumentedEmptyBlock = Internal + 460;
0846:
0847: /*
0848: * Javadoc comments
0849: */
0850: /**
0851: * Problem warned on duplicated tag.
0852: * @since 3.3
0853: */
0854: int JavadocDuplicateTag = Javadoc + Internal + 464;
0855: /**
0856: * Problem signaled on an hidden reference due to a too low visibility level.
0857: * @since 3.3
0858: */
0859: int JavadocHiddenReference = Javadoc + Internal + 465;
0860: /**
0861: * Problem signaled on an invalid qualification for member type reference.
0862: * @since 3.3
0863: */
0864: int JavadocInvalidMemberTypeQualification = Javadoc + Internal
0865: + 466;
0866: /** @since 3.2 */
0867: int JavadocMissingIdentifier = Javadoc + Internal + 467;
0868: /** @since 3.2 */
0869: int JavadocNonStaticTypeFromStaticInvocation = Javadoc + Internal
0870: + 468;
0871: /** @since 3.1 */
0872: int JavadocInvalidParamTagTypeParameter = Javadoc + Internal + 469;
0873: /** @since 3.0 */
0874: int JavadocUnexpectedTag = Javadoc + Internal + 470;
0875: /** @since 3.0 */
0876: int JavadocMissingParamTag = Javadoc + Internal + 471;
0877: /** @since 3.0 */
0878: int JavadocMissingParamName = Javadoc + Internal + 472;
0879: /** @since 3.0 */
0880: int JavadocDuplicateParamName = Javadoc + Internal + 473;
0881: /** @since 3.0 */
0882: int JavadocInvalidParamName = Javadoc + Internal + 474;
0883: /** @since 3.0 */
0884: int JavadocMissingReturnTag = Javadoc + Internal + 475;
0885: /** @since 3.0 */
0886: int JavadocDuplicateReturnTag = Javadoc + Internal + 476;
0887: /** @since 3.0 */
0888: int JavadocMissingThrowsTag = Javadoc + Internal + 477;
0889: /** @since 3.0 */
0890: int JavadocMissingThrowsClassName = Javadoc + Internal + 478;
0891: /** @since 3.0 */
0892: int JavadocInvalidThrowsClass = Javadoc + Internal + 479;
0893: /** @since 3.0 */
0894: int JavadocDuplicateThrowsClassName = Javadoc + Internal + 480;
0895: /** @since 3.0 */
0896: int JavadocInvalidThrowsClassName = Javadoc + Internal + 481;
0897: /** @since 3.0 */
0898: int JavadocMissingSeeReference = Javadoc + Internal + 482;
0899: /** @since 3.0 */
0900: int JavadocInvalidSeeReference = Javadoc + Internal + 483;
0901: /** @since 3.0 */
0902: int JavadocInvalidSeeHref = Javadoc + Internal + 484;
0903: /** @since 3.0 */
0904: int JavadocInvalidSeeArgs = Javadoc + Internal + 485;
0905: /** @since 3.0 */
0906: int JavadocMissing = Javadoc + Internal + 486;
0907: /** @since 3.0 */
0908: int JavadocInvalidTag = Javadoc + Internal + 487;
0909: /*
0910: * ID for field errors in Javadoc
0911: */
0912: /** @since 3.0 */
0913: int JavadocUndefinedField = Javadoc + Internal + 488;
0914: /** @since 3.0 */
0915: int JavadocNotVisibleField = Javadoc + Internal + 489;
0916: /** @since 3.0 */
0917: int JavadocAmbiguousField = Javadoc + Internal + 490;
0918: /** @since 3.0 */
0919: int JavadocUsingDeprecatedField = Javadoc + Internal + 491;
0920: /*
0921: * IDs for constructor errors in Javadoc
0922: */
0923: /** @since 3.0 */
0924: int JavadocUndefinedConstructor = Javadoc + Internal + 492;
0925: /** @since 3.0 */
0926: int JavadocNotVisibleConstructor = Javadoc + Internal + 493;
0927: /** @since 3.0 */
0928: int JavadocAmbiguousConstructor = Javadoc + Internal + 494;
0929: /** @since 3.0 */
0930: int JavadocUsingDeprecatedConstructor = Javadoc + Internal + 495;
0931: /*
0932: * IDs for method errors in Javadoc
0933: */
0934: /** @since 3.0 */
0935: int JavadocUndefinedMethod = Javadoc + Internal + 496;
0936: /** @since 3.0 */
0937: int JavadocNotVisibleMethod = Javadoc + Internal + 497;
0938: /** @since 3.0 */
0939: int JavadocAmbiguousMethod = Javadoc + Internal + 498;
0940: /** @since 3.0 */
0941: int JavadocUsingDeprecatedMethod = Javadoc + Internal + 499;
0942: /** @since 3.0 */
0943: int JavadocNoMessageSendOnBaseType = Javadoc + Internal + 500;
0944: /** @since 3.0 */
0945: int JavadocParameterMismatch = Javadoc + Internal + 501;
0946: /** @since 3.0 */
0947: int JavadocNoMessageSendOnArrayType = Javadoc + Internal + 502;
0948: /*
0949: * IDs for type errors in Javadoc
0950: */
0951: /** @since 3.0 */
0952: int JavadocUndefinedType = Javadoc + Internal + 503;
0953: /** @since 3.0 */
0954: int JavadocNotVisibleType = Javadoc + Internal + 504;
0955: /** @since 3.0 */
0956: int JavadocAmbiguousType = Javadoc + Internal + 505;
0957: /** @since 3.0 */
0958: int JavadocUsingDeprecatedType = Javadoc + Internal + 506;
0959: /** @since 3.0 */
0960: int JavadocInternalTypeNameProvided = Javadoc + Internal + 507;
0961: /** @since 3.0 */
0962: int JavadocInheritedMethodHidesEnclosingName = Javadoc + Internal
0963: + 508;
0964: /** @since 3.0 */
0965: int JavadocInheritedFieldHidesEnclosingName = Javadoc + Internal
0966: + 509;
0967: /** @since 3.0 */
0968: int JavadocInheritedNameHidesEnclosingTypeName = Javadoc + Internal
0969: + 510;
0970: /** @since 3.0 */
0971: int JavadocAmbiguousMethodReference = Javadoc + Internal + 511;
0972: /** @since 3.0 */
0973: int JavadocUnterminatedInlineTag = Javadoc + Internal + 512;
0974: /** @since 3.0 */
0975: int JavadocMalformedSeeReference = Javadoc + Internal + 513;
0976: /** @since 3.0 */
0977: int JavadocMessagePrefix = Internal + 514;
0978:
0979: /** @since 3.1 */
0980: int JavadocMissingHashCharacter = Javadoc + Internal + 515;
0981: /** @since 3.1 */
0982: int JavadocEmptyReturnTag = Javadoc + Internal + 516;
0983: /** @since 3.1 */
0984: int JavadocInvalidValueReference = Javadoc + Internal + 517;
0985: /** @since 3.1 */
0986: int JavadocUnexpectedText = Javadoc + Internal + 518;
0987: /** @since 3.1 */
0988: int JavadocInvalidParamTagName = Javadoc + Internal + 519;
0989:
0990: /**
0991: * Generics
0992: */
0993: /** @since 3.1 */
0994: int DuplicateTypeVariable = Internal + 520;
0995: /** @since 3.1 */
0996: int IllegalTypeVariableSuperReference = Internal + 521;
0997: /** @since 3.1 */
0998: int NonStaticTypeFromStaticInvocation = Internal + 522;
0999: /** @since 3.1 */
1000: int ObjectCannotBeGeneric = Internal + 523;
1001: /** @since 3.1 */
1002: int NonGenericType = TypeRelated + 524;
1003: /** @since 3.1 */
1004: int IncorrectArityForParameterizedType = TypeRelated + 525;
1005: /** @since 3.1 */
1006: int TypeArgumentMismatch = TypeRelated + 526;
1007: /** @since 3.1 */
1008: int DuplicateMethodErasure = TypeRelated + 527;
1009: /** @since 3.1 */
1010: int ReferenceToForwardTypeVariable = TypeRelated + 528;
1011: /** @since 3.1 */
1012: int BoundMustBeAnInterface = TypeRelated + 529;
1013: /** @since 3.1 */
1014: int UnsafeRawConstructorInvocation = TypeRelated + 530;
1015: /** @since 3.1 */
1016: int UnsafeRawMethodInvocation = TypeRelated + 531;
1017: /** @since 3.1 */
1018: int UnsafeTypeConversion = TypeRelated + 532;
1019: /** @since 3.1 */
1020: int InvalidTypeVariableExceptionType = TypeRelated + 533;
1021: /** @since 3.1 */
1022: int InvalidParameterizedExceptionType = TypeRelated + 534;
1023: /** @since 3.1 */
1024: int IllegalGenericArray = TypeRelated + 535;
1025: /** @since 3.1 */
1026: int UnsafeRawFieldAssignment = TypeRelated + 536;
1027: /** @since 3.1 */
1028: int FinalBoundForTypeVariable = TypeRelated + 537;
1029: /** @since 3.1 */
1030: int UndefinedTypeVariable = Internal + 538;
1031: /** @since 3.1 */
1032: int SuperInterfacesCollide = TypeRelated + 539;
1033: /** @since 3.1 */
1034: int WildcardConstructorInvocation = TypeRelated + 540;
1035: /** @since 3.1 */
1036: int WildcardMethodInvocation = TypeRelated + 541;
1037: /** @since 3.1 */
1038: int WildcardFieldAssignment = TypeRelated + 542;
1039: /** @since 3.1 */
1040: int GenericMethodTypeArgumentMismatch = TypeRelated + 543;
1041: /** @since 3.1 */
1042: int GenericConstructorTypeArgumentMismatch = TypeRelated + 544;
1043: /** @since 3.1 */
1044: int UnsafeGenericCast = TypeRelated + 545;
1045: /** @since 3.1 */
1046: int IllegalInstanceofParameterizedType = Internal + 546;
1047: /** @since 3.1 */
1048: int IllegalInstanceofTypeParameter = Internal + 547;
1049: /** @since 3.1 */
1050: int NonGenericMethod = TypeRelated + 548;
1051: /** @since 3.1 */
1052: int IncorrectArityForParameterizedMethod = TypeRelated + 549;
1053: /** @since 3.1 */
1054: int ParameterizedMethodArgumentTypeMismatch = TypeRelated + 550;
1055: /** @since 3.1 */
1056: int NonGenericConstructor = TypeRelated + 551;
1057: /** @since 3.1 */
1058: int IncorrectArityForParameterizedConstructor = TypeRelated + 552;
1059: /** @since 3.1 */
1060: int ParameterizedConstructorArgumentTypeMismatch = TypeRelated + 553;
1061: /** @since 3.1 */
1062: int TypeArgumentsForRawGenericMethod = TypeRelated + 554;
1063: /** @since 3.1 */
1064: int TypeArgumentsForRawGenericConstructor = TypeRelated + 555;
1065: /** @since 3.1 */
1066: int SuperTypeUsingWildcard = TypeRelated + 556;
1067: /** @since 3.1 */
1068: int GenericTypeCannotExtendThrowable = TypeRelated + 557;
1069: /** @since 3.1 */
1070: int IllegalClassLiteralForTypeVariable = TypeRelated + 558;
1071: /** @since 3.1 */
1072: int UnsafeReturnTypeOverride = MethodRelated + 559;
1073: /** @since 3.1 */
1074: int MethodNameClash = MethodRelated + 560;
1075: /** @since 3.1 */
1076: int RawMemberTypeCannotBeParameterized = TypeRelated + 561;
1077: /** @since 3.1 */
1078: int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;
1079: /** @since 3.1 */
1080: int StaticMemberOfParameterizedType = TypeRelated + 563;
1081: /** @since 3.1 */
1082: int BoundHasConflictingArguments = TypeRelated + 564;
1083: /** @since 3.1 */
1084: int DuplicateParameterizedMethods = MethodRelated + 565;
1085: /** @since 3.1 */
1086: int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;
1087: /** @since 3.1 */
1088: int DuplicateBounds = TypeRelated + 567;
1089: /** @since 3.1 */
1090: int BoundCannotBeArray = TypeRelated + 568;
1091: /** @since 3.1 */
1092: int UnsafeRawGenericConstructorInvocation = TypeRelated + 569;
1093: /** @since 3.1 */
1094: int UnsafeRawGenericMethodInvocation = TypeRelated + 570;
1095: /** @since 3.1 */
1096: int TypeParameterHidingType = TypeRelated + 571;
1097: /** @since 3.2 */
1098: int RawTypeReference = TypeRelated + 572;
1099: /** @since 3.2 */
1100: int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;
1101: /** @since 3.2 */
1102: int UnsafeGenericArrayForVarargs = MethodRelated + 574;
1103: /** @since 3.2 */
1104: int IllegalAccessFromTypeVariable = TypeRelated + 575;
1105: /** @since 3.3 */
1106: int TypeHidingTypeParameterFromType = TypeRelated + 576;
1107: /** @since 3.3 */
1108: int TypeHidingTypeParameterFromMethod = TypeRelated + 577;
1109: /** @since 3.3 */
1110: int InvalidUsageOfWildcard = Syntax + Internal + 578;
1111:
1112: /**
1113: * Foreach
1114: */
1115: /** @since 3.1 */
1116: int IncompatibleTypesInForeach = TypeRelated + 580;
1117: /** @since 3.1 */
1118: int InvalidTypeForCollection = Internal + 581;
1119:
1120: /**
1121: * 1.5 Syntax errors (when source level < 1.5)
1122: */
1123: /** @since 3.1 */
1124: int InvalidUsageOfTypeParameters = Syntax + Internal + 590;
1125: /** @since 3.1 */
1126: int InvalidUsageOfStaticImports = Syntax + Internal + 591;
1127: /** @since 3.1 */
1128: int InvalidUsageOfForeachStatements = Syntax + Internal + 592;
1129: /** @since 3.1 */
1130: int InvalidUsageOfTypeArguments = Syntax + Internal + 593;
1131: /** @since 3.1 */
1132: int InvalidUsageOfEnumDeclarations = Syntax + Internal + 594;
1133: /** @since 3.1 */
1134: int InvalidUsageOfVarargs = Syntax + Internal + 595;
1135: /** @since 3.1 */
1136: int InvalidUsageOfAnnotations = Syntax + Internal + 596;
1137: /** @since 3.1 */
1138: int InvalidUsageOfAnnotationDeclarations = Syntax + Internal + 597;
1139: /** @since 3.4 */
1140: int InvalidUsageOfTypeParametersForAnnotationDeclaration = Syntax
1141: + Internal + 598;
1142: /** @since 3.4 */
1143: int InvalidUsageOfTypeParametersForEnumDeclaration = Syntax
1144: + Internal + 599;
1145: /**
1146: * Annotation
1147: */
1148: /** @since 3.1 */
1149: int IllegalModifierForAnnotationMethod = MethodRelated + 600;
1150: /** @since 3.1 */
1151: int IllegalExtendedDimensions = MethodRelated + 601;
1152: /** @since 3.1 */
1153: int InvalidFileNameForPackageAnnotations = Syntax + Internal + 602;
1154: /** @since 3.1 */
1155: int IllegalModifierForAnnotationType = TypeRelated + 603;
1156: /** @since 3.1 */
1157: int IllegalModifierForAnnotationMemberType = TypeRelated + 604;
1158: /** @since 3.1 */
1159: int InvalidAnnotationMemberType = TypeRelated + 605;
1160: /** @since 3.1 */
1161: int AnnotationCircularitySelfReference = TypeRelated + 606;
1162: /** @since 3.1 */
1163: int AnnotationCircularity = TypeRelated + 607;
1164: /** @since 3.1 */
1165: int DuplicateAnnotation = TypeRelated + 608;
1166: /** @since 3.1 */
1167: int MissingValueForAnnotationMember = TypeRelated + 609;
1168: /** @since 3.1 */
1169: int DuplicateAnnotationMember = Internal + 610;
1170: /** @since 3.1 */
1171: int UndefinedAnnotationMember = MethodRelated + 611;
1172: /** @since 3.1 */
1173: int AnnotationValueMustBeClassLiteral = Internal + 612;
1174: /** @since 3.1 */
1175: int AnnotationValueMustBeConstant = Internal + 613;
1176: /** @deprecated - problem is no longer generated (code is legite)
1177: * @since 3.1 */
1178: int AnnotationFieldNeedConstantInitialization = Internal + 614;
1179: /** @since 3.1 */
1180: int IllegalModifierForAnnotationField = Internal + 615;
1181: /** @since 3.1 */
1182: int AnnotationCannotOverrideMethod = MethodRelated + 616;
1183: /** @since 3.1 */
1184: int AnnotationMembersCannotHaveParameters = Syntax + Internal + 617;
1185: /** @since 3.1 */
1186: int AnnotationMembersCannotHaveTypeParameters = Syntax + Internal
1187: + 618;
1188: /** @since 3.1 */
1189: int AnnotationTypeDeclarationCannotHaveSuperclass = Syntax
1190: + Internal + 619;
1191: /** @since 3.1 */
1192: int AnnotationTypeDeclarationCannotHaveSuperinterfaces = Syntax
1193: + Internal + 620;
1194: /** @since 3.1 */
1195: int DuplicateTargetInTargetAnnotation = Internal + 621;
1196: /** @since 3.1 */
1197: int DisallowedTargetForAnnotation = TypeRelated + 622;
1198: /** @since 3.1 */
1199: int MethodMustOverride = MethodRelated + 623;
1200: /** @since 3.1 */
1201: int AnnotationTypeDeclarationCannotHaveConstructor = Syntax
1202: + Internal + 624;
1203: /** @since 3.1 */
1204: int AnnotationValueMustBeAnnotation = Internal + 625;
1205: /** @since 3.1 */
1206: int AnnotationTypeUsedAsSuperInterface = TypeRelated + 626;
1207: /** @since 3.1 */
1208: int MissingOverrideAnnotation = MethodRelated + 627;
1209: /** @since 3.1 */
1210: int FieldMissingDeprecatedAnnotation = Internal + 628;
1211: /** @since 3.1 */
1212: int MethodMissingDeprecatedAnnotation = Internal + 629;
1213: /** @since 3.1 */
1214: int TypeMissingDeprecatedAnnotation = Internal + 630;
1215: /** @since 3.1 */
1216: int UnhandledWarningToken = Internal + 631;
1217: /** @since 3.2 */
1218: int AnnotationValueMustBeArrayInitializer = Internal + 632;
1219: /** @since 3.3 */
1220: int AnnotationValueMustBeAnEnumConstant = Internal + 633;
1221: /** @since 3.3 */
1222: int MethodMustOverrideOrImplement = MethodRelated + 634;
1223:
1224: /**
1225: * Corrupted binaries
1226: */
1227: /** @since 3.1 */
1228: int CorruptedSignature = Internal + 700;
1229: /**
1230: * Corrupted source
1231: */
1232: /** @since 3.2 */
1233: int InvalidEncoding = Internal + 701;
1234: /** @since 3.2 */
1235: int CannotReadSource = Internal + 702;
1236:
1237: /**
1238: * Autoboxing
1239: */
1240: /** @since 3.1 */
1241: int BoxingConversion = Internal + 720;
1242: /** @since 3.1 */
1243: int UnboxingConversion = Internal + 721;
1244:
1245: /**
1246: * Enum
1247: */
1248: /** @since 3.1 */
1249: int IllegalModifierForEnum = TypeRelated + 750;
1250: /** @since 3.1 */
1251: int IllegalModifierForEnumConstant = FieldRelated + 751;
1252: /** @since 3.1 */
1253: int IllegalModifierForLocalEnum = TypeRelated + 752;
1254: /** @since 3.1 */
1255: int IllegalModifierForMemberEnum = TypeRelated + 753;
1256: /** @since 3.1 */
1257: int CannotDeclareEnumSpecialMethod = MethodRelated + 754;
1258: /** @since 3.1 */
1259: int IllegalQualifiedEnumConstantLabel = FieldRelated + 755;
1260: /** @since 3.1 */
1261: int CannotExtendEnum = TypeRelated + 756;
1262: /** @since 3.1 */
1263: int CannotInvokeSuperConstructorInEnum = MethodRelated + 757;
1264: /** @since 3.1 */
1265: int EnumAbstractMethodMustBeImplemented = MethodRelated + 758;
1266: /** @since 3.1 */
1267: int EnumSwitchCannotTargetField = FieldRelated + 759;
1268: /** @since 3.1 */
1269: int IllegalModifierForEnumConstructor = MethodRelated + 760;
1270: /** @since 3.1 */
1271: int MissingEnumConstantCase = FieldRelated + 761;
1272: /** @since 3.2 */
1273: // TODO need to fix 3.1.1 contribution (inline this constant on client side)
1274: int EnumStaticFieldInInInitializerContext = FieldRelated + 762;
1275:
1276: /**
1277: * Var args
1278: */
1279: /** @since 3.1 */
1280: int IllegalExtendedDimensionsForVarArgs = Syntax + Internal + 800;
1281: /** @since 3.1 */
1282: int MethodVarargsArgumentNeedCast = MethodRelated + 801;
1283: /** @since 3.1 */
1284: int ConstructorVarargsArgumentNeedCast = ConstructorRelated + 802;
1285: /** @since 3.1 */
1286: int VarargsConflict = MethodRelated + 803;
1287:
1288: /**
1289: * Javadoc Generic
1290: */
1291: /** @since 3.1 */
1292: int JavadocGenericMethodTypeArgumentMismatch = Javadoc + Internal
1293: + 850;
1294: /** @since 3.1 */
1295: int JavadocNonGenericMethod = Javadoc + Internal + 851;
1296: /** @since 3.1 */
1297: int JavadocIncorrectArityForParameterizedMethod = Javadoc
1298: + Internal + 852;
1299: /** @since 3.1 */
1300: int JavadocParameterizedMethodArgumentTypeMismatch = Javadoc
1301: + Internal + 853;
1302: /** @since 3.1 */
1303: int JavadocTypeArgumentsForRawGenericMethod = Javadoc + Internal
1304: + 854;
1305: /** @since 3.1 */
1306: int JavadocGenericConstructorTypeArgumentMismatch = Javadoc
1307: + Internal + 855;
1308: /** @since 3.1 */
1309: int JavadocNonGenericConstructor = Javadoc + Internal + 856;
1310: /** @since 3.1 */
1311: int JavadocIncorrectArityForParameterizedConstructor = Javadoc
1312: + Internal + 857;
1313: /** @since 3.1 */
1314: int JavadocParameterizedConstructorArgumentTypeMismatch = Javadoc
1315: + Internal + 858;
1316: /** @since 3.1 */
1317: int JavadocTypeArgumentsForRawGenericConstructor = Javadoc
1318: + Internal + 859;
1319:
1320: /**
1321: * External problems -- These are problems defined by other plugins
1322: */
1323:
1324: /** @since 3.2 */
1325: int ExternalProblemNotFixable = 900;
1326:
1327: // indicates an externally defined problem that has a quick-assist processor
1328: // associated with it
1329: /** @since 3.2 */
1330: int ExternalProblemFixable = 901;
1331: }
|