KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > core > compiler > IProblem


1 /*******************************************************************************
2  * Copyright (c) 2000, 2007 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  * IBM Corporation - added the following constants
11  * NonStaticAccessToStaticField
12  * NonStaticAccessToStaticMethod
13  * Task
14  * ExpressionShouldBeAVariable
15  * AssignmentHasNoEffect
16  * IBM Corporation - added the following constants
17  * TooManySyntheticArgumentSlots
18  * TooManyArrayDimensions
19  * TooManyBytesForStringConstant
20  * TooManyMethods
21  * TooManyFields
22  * NonBlankFinalLocalAssignment
23  * ObjectCannotHaveSuperTypes
24  * MissingSemiColon
25  * InvalidParenthesizedExpression
26  * EnclosingInstanceInConstructorCall
27  * BytecodeExceeds64KLimitForConstructor
28  * IncompatibleReturnTypeForNonInheritedInterfaceMethod
29  * UnusedPrivateMethod
30  * UnusedPrivateConstructor
31  * UnusedPrivateType
32  * UnusedPrivateField
33  * IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
34  * InvalidExplicitConstructorCall
35  * IBM Corporation - added the following constants
36  * PossibleAccidentalBooleanAssignment
37  * SuperfluousSemicolon
38  * IndirectAccessToStaticField
39  * IndirectAccessToStaticMethod
40  * IndirectAccessToStaticType
41  * BooleanMethodThrowingException
42  * UnnecessaryCast
43  * UnnecessaryArgumentCast
44  * UnnecessaryInstanceof
45  * FinallyMustCompleteNormally
46  * UnusedMethodDeclaredThrownException
47  * UnusedConstructorDeclaredThrownException
48  * InvalidCatchBlockSequence
49  * UnqualifiedFieldAccess
50  * IBM Corporation - added the following constants
51  * Javadoc
52  * JavadocUnexpectedTag
53  * JavadocMissingParamTag
54  * JavadocMissingParamName
55  * JavadocDuplicateParamName
56  * JavadocInvalidParamName
57  * JavadocMissingReturnTag
58  * JavadocDuplicateReturnTag
59  * JavadocMissingThrowsTag
60  * JavadocMissingThrowsClassName
61  * JavadocInvalidThrowsClass
62  * JavadocDuplicateThrowsClassName
63  * JavadocInvalidThrowsClassName
64  * JavadocMissingSeeReference
65  * JavadocInvalidSeeReference
66  * JavadocInvalidSeeHref
67  * JavadocInvalidSeeArgs
68  * JavadocMissing
69  * JavadocInvalidTag
70  * JavadocMessagePrefix
71  * EmptyControlFlowStatement
72  * IBM Corporation - added the following constants
73  * IllegalUsageOfQualifiedTypeReference
74  * InvalidDigit
75  * IBM Corporation - added the following constants
76  * ParameterAssignment
77  * FallthroughCase
78  * IBM Corporation - added the following constants
79  * UnusedLabel
80  * UnnecessaryNLSTag
81  * LocalVariableMayBeNull
82  * EnumConstantsCannotBeSurroundedByParenthesis
83  * JavadocMissingIdentifier
84  * JavadocNonStaticTypeFromStaticInvocation
85  * RawTypeReference
86  * NoAdditionalBoundAfterTypeVariable
87  * UnsafeGenericArrayForVarargs
88  * IllegalAccessFromTypeVariable
89  * AnnotationValueMustBeArrayInitializer
90  * InvalidEncoding
91  * CannotReadSource
92  * EnumStaticFieldInInInitializerContext
93  * ExternalProblemNotFixable
94  * ExternalProblemFixable
95  * IBM Corporation - added the following constants
96  * AnnotationValueMustBeAnEnumConstant
97  * OverridingMethodWithoutSuperInvocation
98  * MethodMustOverrideOrImplement
99  * TypeHidingTypeParameterFromType
100  * TypeHidingTypeParameterFromMethod
101  * TypeHidingType
102  * IBM Corporation - added the following constants
103  * NullLocalVariableReference
104  * PotentialNullLocalVariableReference
105  * RedundantNullCheckOnNullLocalVariable
106  * NullLocalVariableComparisonYieldsFalse
107  * RedundantLocalVariableNullAssignment
108  * NullLocalVariableInstanceofYieldsFalse
109  * RedundantNullCheckOnNonNullLocalVariable
110  * NonNullLocalVariableComparisonYieldsFalse
111  *******************************************************************************/
112 package org.eclipse.jdt.core.compiler;
113  
114 import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
115
116 /**
117  * Description of a Java problem, as detected by the compiler or some of the underlying
118  * technology reusing the compiler.
119  * A problem provides access to:
120  * <ul>
121  * <li> its location (originating source file name, source position, line number), </li>
122  * <li> its message description and a predicate to check its severity (warning or error). </li>
123  * <li> its ID : a number identifying the very nature of this problem. All possible IDs are listed
124  * as constants on this interface. </li>
125  * </ul>
126  *
127  * Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder
128  * so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected
129  * when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular
130  * their ID (attribute "id") is set to one of the IDs defined on this interface.
131  *
132  * @since 2.0
133  */
134 public interface IProblem {
135     
136 /**
137  * Answer back the original arguments recorded into the problem.
138  * @return the original arguments recorded into the problem
139  */
140 String JavaDoc[] getArguments();
141
142 /**
143  * Returns the problem id
144  *
145  * @return the problem id
146  */
147 int getID();
148
149 /**
150  * Answer a localized, human-readable message string which describes the problem.
151  *
152  * @return a localized, human-readable message string which describes the problem
153  */
154 String JavaDoc getMessage();
155
156 /**
157  * Answer the file name in which the problem was found.
158  *
159  * @return the file name in which the problem was found
160  */
161 char[] getOriginatingFileName();
162
163 /**
164  * Answer the end position of the problem (inclusive), or -1 if unknown.
165  *
166  * @return the end position of the problem (inclusive), or -1 if unknown
167  */
168 int getSourceEnd();
169
170 /**
171  * Answer the line number in source where the problem begins.
172  *
173  * @return the line number in source where the problem begins
174  */
175 int getSourceLineNumber();
176
177 /**
178  * Answer the start position of the problem (inclusive), or -1 if unknown.
179  *
180  * @return the start position of the problem (inclusive), or -1 if unknown
181  */
182 int getSourceStart();
183
184 /**
185  * Checks the severity to see if the Error bit is set.
186  *
187  * @return true if the Error bit is set for the severity, false otherwise
188  */
189 boolean isError();
190
191 /**
192  * Checks the severity to see if the Error bit is not set.
193  *
194  * @return true if the Error bit is not set for the severity, false otherwise
195  */
196 boolean isWarning();
197
198 /**
199  * Set the end position of the problem (inclusive), or -1 if unknown.
200  * Used for shifting problem positions.
201  *
202  * @param sourceEnd the given end position
203  */
204 void setSourceEnd(int sourceEnd);
205
206 /**
207  * Set the line number in source where the problem begins.
208  *
209  * @param lineNumber the given line number
210  */
211 void setSourceLineNumber(int lineNumber);
212
213 /**
214  * Set the start position of the problem (inclusive), or -1 if unknown.
215  * Used for shifting problem positions.
216  *
217  * @param sourceStart the given start position
218  */
219 void setSourceStart(int sourceStart);
220
221
222     /**
223      * Problem Categories
224      * The high bits of a problem ID contains information about the category of a problem.
225      * For example, (problemID & TypeRelated) != 0, indicates that this problem is type related.
226      *
227      * A problem category can help to implement custom problem filters. Indeed, when numerous problems
228      * are listed, focusing on import related problems first might be relevant.
229      *
230      * When a problem is tagged as Internal, it means that no change other than a local source code change
231      * can fix the corresponding problem. A type related problem could be addressed by changing the type
232      * involved in it.
233      */
234     int TypeRelated = 0x01000000;
235     int FieldRelated = 0x02000000;
236     int MethodRelated = 0x04000000;
237     int ConstructorRelated = 0x08000000;
238     int ImportRelated = 0x10000000;
239     int Internal = 0x20000000;
240     int Syntax = 0x40000000;
241     /** @since 3.0 */
242     int Javadoc = 0x80000000;
243     
244     /**
245      * Mask to use in order to filter out the category portion of the problem ID.
246      */
247     int IgnoreCategoriesMask = 0xFFFFFF;
248
249     /**
250      * Below are listed all available problem IDs. Note that this list could be augmented in the future,
251      * as new features are added to the Java core implementation.
252      */
253
254     /**
255      * ID reserved for referencing an internal error inside the JavaCore implementation which
256      * may be surfaced as a problem associated with the compilation unit which caused it to occur.
257      */
258     int Unclassified = 0;
259
260     /**
261      * General type related problems
262      */
263     int ObjectHasNoSuperclass = TypeRelated + 1;
264     int UndefinedType = TypeRelated + 2;
265     int NotVisibleType = TypeRelated + 3;
266     int AmbiguousType = TypeRelated + 4;
267     int UsingDeprecatedType = TypeRelated + 5;
268     int InternalTypeNameProvided = TypeRelated + 6;
269     /** @since 2.1 */
270     int UnusedPrivateType = Internal + TypeRelated + 7;
271
272     int IncompatibleTypesInEqualityOperator = TypeRelated + 15;
273     int IncompatibleTypesInConditionalOperator = TypeRelated + 16;
274     int TypeMismatch = TypeRelated + 17;
275     /** @since 3.0 */
276     int IndirectAccessToStaticType = Internal + TypeRelated + 18;
277     
278     /**
279      * Inner types related problems
280      */
281     int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
282     int MissingEnclosingInstance = TypeRelated + 21;
283     int IncorrectEnclosingInstanceReference = TypeRelated + 22;
284     int IllegalEnclosingInstanceSpecification = TypeRelated + 23;
285     int CannotDefineStaticInitializerInLocalType = Internal + 24;
286     int OuterLocalMustBeFinal = Internal + 25;
287     int CannotDefineInterfaceInLocalType = Internal + 26;
288     int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27;
289     /** @since 2.1 */
290     int EnclosingInstanceInConstructorCall = Internal + 28;
291     int AnonymousClassCannotExtendFinalClass = TypeRelated + 29;
292     /** @since 3.1 */
293     int CannotDefineAnnotationInLocalType = Internal + 30;
294     /** @since 3.1 */
295     int CannotDefineEnumInLocalType = Internal + 31;
296     /** @since 3.1 */
297     int NonStaticContextForEnumMemberType = Internal + 32;
298     /** @since 3.3 */
299     int TypeHidingType = TypeRelated + 33;
300     
301     // variables
302 int UndefinedName = Internal + FieldRelated + 50;
303     int UninitializedLocalVariable = Internal + 51;
304     int VariableTypeCannotBeVoid = Internal + 52;
305     /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
306     int VariableTypeCannotBeVoidArray = Internal + 53;
307     int CannotAllocateVoidArray = Internal + 54;
308     // local variables
309 int RedefinedLocal = Internal + 55;
310     int RedefinedArgument = Internal + 56;
311     // final local variables
312 int DuplicateFinalLocalInitialization = Internal + 57;
313     /** @since 2.1 */
314     int NonBlankFinalLocalAssignment = Internal + 58;
315     /** @since 3.2 */
316     int ParameterAssignment = Internal + 59;
317     int FinalOuterLocalAssignment = Internal + 60;
318     int LocalVariableIsNeverUsed = Internal + 61;
319     int ArgumentIsNeverUsed = Internal + 62;
320     int BytecodeExceeds64KLimit = Internal + 63;
321     int BytecodeExceeds64KLimitForClinit = Internal + 64;
322     int TooManyArgumentSlots = Internal + 65;
323     int TooManyLocalVariableSlots = Internal + 66;
324     /** @since 2.1 */
325     int TooManySyntheticArgumentSlots = Internal + 67;
326     /** @since 2.1 */
327     int TooManyArrayDimensions = Internal + 68;
328     /** @since 2.1 */
329     int BytecodeExceeds64KLimitForConstructor = Internal + 69;
330     
331     // fields
332 int UndefinedField = FieldRelated + 70;
333     int NotVisibleField = FieldRelated + 71;
334     int AmbiguousField = FieldRelated + 72;
335     int UsingDeprecatedField = FieldRelated + 73;
336     int NonStaticFieldFromStaticInvocation = FieldRelated + 74;
337     int ReferenceToForwardField = FieldRelated + Internal + 75;
338     /** @since 2.1 */
339     int NonStaticAccessToStaticField = Internal + FieldRelated + 76;
340     /** @since 2.1 */
341     int UnusedPrivateField = Internal + FieldRelated + 77;
342     /** @since 3.0 */
343     int IndirectAccessToStaticField = Internal + FieldRelated + 78;
344     /** @since 3.0 */
345     int UnqualifiedFieldAccess = Internal + FieldRelated + 79;
346     
347     // blank final fields
348 int FinalFieldAssignment = FieldRelated + 80;
349     int UninitializedBlankFinalField = FieldRelated + 81;
350     int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
351
352     // variable hiding
353 /** @since 3.0 */
354     int LocalVariableHidingLocalVariable = Internal + 90;
355     /** @since 3.0 */
356     int LocalVariableHidingField = Internal + FieldRelated + 91;
357     /** @since 3.0 */
358     int FieldHidingLocalVariable = Internal + FieldRelated + 92;
359     /** @since 3.0 */
360     int FieldHidingField = Internal + FieldRelated + 93;
361     /** @since 3.0 */
362     int ArgumentHidingLocalVariable = Internal + 94;
363     /** @since 3.0 */
364     int ArgumentHidingField = Internal + 95;
365     /** @since 3.1 */
366     int MissingSerialVersion = Internal + 96;
367     
368     // methods
369 int UndefinedMethod = MethodRelated + 100;
370     int NotVisibleMethod = MethodRelated + 101;
371     int AmbiguousMethod = MethodRelated + 102;
372     int UsingDeprecatedMethod = MethodRelated + 103;
373     int DirectInvocationOfAbstractMethod = MethodRelated + 104;
374     int VoidMethodReturnsValue = MethodRelated + 105;
375     int MethodReturnsVoid = MethodRelated + 106;
376     int MethodRequiresBody = Internal + MethodRelated + 107;
377     int ShouldReturnValue = Internal + MethodRelated + 108;
378     int MethodButWithConstructorName = MethodRelated + 110;
379     int MissingReturnType = TypeRelated + 111;
380     int BodyForNativeMethod = Internal + MethodRelated + 112;
381     int BodyForAbstractMethod = Internal + MethodRelated + 113;
382     int NoMessageSendOnBaseType = MethodRelated + 114;
383     int ParameterMismatch = MethodRelated + 115;
384     int NoMessageSendOnArrayType = MethodRelated + 116;
385     /** @since 2.1 */
386     int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117;
387     /** @since 2.1 */
388     int UnusedPrivateMethod = Internal + MethodRelated + 118;
389     /** @since 3.0 */
390     int IndirectAccessToStaticMethod = Internal + MethodRelated + 119;
391
392     // constructors
393 int UndefinedConstructor = ConstructorRelated + 130;
394     int NotVisibleConstructor = ConstructorRelated + 131;
395     int AmbiguousConstructor = ConstructorRelated + 132;
396     int UsingDeprecatedConstructor = ConstructorRelated + 133;
397     /** @since 2.1 */
398     int UnusedPrivateConstructor = Internal + MethodRelated + 134;
399     // explicit constructor calls
400 int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135;
401     int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136;
402     int RecursiveConstructorInvocation = ConstructorRelated + 137;
403     int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138;
404     /** @since 3.0 */
405     int InvalidExplicitConstructorCall = ConstructorRelated + Syntax + 139;
406     // implicit constructor calls
407 int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140;
408     int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141;
409     int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142;
410     int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143;
411     int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144;
412     int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145;
413     int UnhandledExceptionInDefaultConstructor = TypeRelated + 146;
414     int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147;
415                 
416     // expressions
417 int ArrayReferenceRequired = Internal + 150;
418     int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
419     // constant expressions
420 int StringConstantIsExceedingUtf8Limit = Internal + 152;
421     int NonConstantExpression = Internal + 153;
422     int NumericValueOutOfRange = Internal + 154;
423     // cast expressions
424 int IllegalCast = TypeRelated + 156;
425     // allocations
426 int InvalidClassInstantiation = TypeRelated + 157;
427     int CannotDefineDimensionExpressionsWithInit = Internal + 158;
428     int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159;
429     // operators
430 int InvalidOperator = Internal + 160;
431     // statements
432 int CodeCannotBeReached = Internal + 161;
433     int CannotReturnInInitializer = Internal + 162;
434     int InitializerMustCompleteNormally = Internal + 163;
435     // assert
436 int InvalidVoidExpression = Internal + 164;
437     // try
438 int MaskedCatch = TypeRelated + 165;
439     int DuplicateDefaultCase = Internal + 166;
440     int UnreachableCatch = TypeRelated + MethodRelated + 167;
441     int UnhandledException = TypeRelated + 168;
442     // switch
443 int IncorrectSwitchType = TypeRelated + 169;
444     int DuplicateCase = FieldRelated + 170;
445
446     // labelled
447 int DuplicateLabel = Internal + 171;
448     int InvalidBreak = Internal + 172;
449     int InvalidContinue = Internal + 173;
450     int UndefinedLabel = Internal + 174;
451     //synchronized
452 int InvalidTypeToSynchronized = Internal + 175;
453     int InvalidNullToSynchronized = Internal + 176;
454     // throw
455 int CannotThrowNull = Internal + 177;
456     // assignment
457 /** @since 2.1 */
458     int AssignmentHasNoEffect = Internal + 178;
459     /** @since 3.0 */
460     int PossibleAccidentalBooleanAssignment = Internal + 179;
461     /** @since 3.0 */
462     int SuperfluousSemicolon = Internal + 180;
463     /** @since 3.0 */
464     int UnnecessaryCast = Internal + TypeRelated + 181;
465     /** @deprecated - no longer generated, use {@link #UnnecessaryCast} instead
466      * @since 3.0 */
467     int UnnecessaryArgumentCast = Internal + TypeRelated + 182;
468     /** @since 3.0 */
469     int UnnecessaryInstanceof = Internal + TypeRelated + 183;
470     /** @since 3.0 */
471     int FinallyMustCompleteNormally = Internal + 184;
472     /** @since 3.0 */
473     int UnusedMethodDeclaredThrownException = Internal + 185;
474     /** @since 3.0 */
475     int UnusedConstructorDeclaredThrownException = Internal + 186;
476     /** @since 3.0 */
477     int InvalidCatchBlockSequence = Internal + TypeRelated + 187;
478     /** @since 3.0 */
479     int EmptyControlFlowStatement = Internal + TypeRelated + 188;
480     /** @since 3.0 */
481     int UnnecessaryElse = Internal + 189;
482
483     // inner emulation
484 int NeedToEmulateFieldReadAccess = FieldRelated + 190;
485     int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
486     int NeedToEmulateMethodAccess = MethodRelated + 192;
487     int NeedToEmulateConstructorAccess = MethodRelated + 193;
488
489     /** @since 3.2 */
490     int FallthroughCase = Internal + 194;
491     
492     //inherited name hides enclosing name (sort of ambiguous)
493 int InheritedMethodHidesEnclosingName = MethodRelated + 195;
494     int InheritedFieldHidesEnclosingName = FieldRelated + 196;
495     int InheritedTypeHidesEnclosingName = TypeRelated + 197;
496
497     /** @since 3.1 */
498     int IllegalUsageOfQualifiedTypeReference = Internal + Syntax + 198;
499
500     // miscellaneous
501 /** @since 3.2 */
502     int UnusedLabel = Internal + 199;
503     int ThisInStaticContext = Internal + 200;
504     int StaticMethodRequested = Internal + MethodRelated + 201;
505     int IllegalDimension = Internal + 202;
506     int InvalidTypeExpression = Internal + 203;
507     int ParsingError = Syntax + Internal + 204;
508     int ParsingErrorNoSuggestion = Syntax + Internal + 205;
509     int InvalidUnaryExpression = Syntax + Internal + 206;
510
511     // syntax errors
512 int InterfaceCannotHaveConstructors = Syntax + Internal + 207;
513     int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208;
514     int ParsingErrorOnKeyword = Syntax + Internal + 209;
515     int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;
516
517     int UnmatchedBracket = Syntax + Internal + 220;
518     int NoFieldOnBaseType = FieldRelated + 221;
519     int InvalidExpressionAsStatement = Syntax + Internal + 222;
520     /** @since 2.1 */
521     int ExpressionShouldBeAVariable = Syntax + Internal + 223;
522     /** @since 2.1 */
523     int MissingSemiColon = Syntax + Internal + 224;
524     /** @since 2.1 */
525     int InvalidParenthesizedExpression = Syntax + Internal + 225;
526     
527     /** @since 3.0 */
528     int ParsingErrorInsertTokenBefore = Syntax + Internal + 230;
529     /** @since 3.0 */
530     int ParsingErrorInsertTokenAfter = Syntax + Internal + 231;
531     /** @since 3.0 */
532     int ParsingErrorDeleteToken = Syntax + Internal + 232;
533     /** @since 3.0 */
534     int ParsingErrorDeleteTokens = Syntax + Internal + 233;
535     /** @since 3.0 */
536     int ParsingErrorMergeTokens = Syntax + Internal + 234;
537     /** @since 3.0 */
538     int ParsingErrorInvalidToken = Syntax + Internal + 235;
539     /** @since 3.0 */
540     int ParsingErrorMisplacedConstruct = Syntax + Internal + 236;
541     /** @since 3.0 */
542     int ParsingErrorReplaceTokens = Syntax + Internal + 237;
543     /** @since 3.0 */
544     int ParsingErrorNoSuggestionForTokens = Syntax + Internal + 238;
545     /** @since 3.0 */
546     int ParsingErrorUnexpectedEOF = Syntax + Internal + 239;
547     /** @since 3.0 */
548     int ParsingErrorInsertToComplete = Syntax + Internal + 240;
549     /** @since 3.0 */
550     int ParsingErrorInsertToCompleteScope = Syntax + Internal + 241;
551     /** @since 3.0 */
552     int ParsingErrorInsertToCompletePhrase = Syntax + Internal + 242;
553     
554     // scanner errors
555 int EndOfSource = Syntax + Internal + 250;
556     int InvalidHexa = Syntax + Internal + 251;
557     int InvalidOctal = Syntax + Internal + 252;
558     int InvalidCharacterConstant = Syntax + Internal + 253;
559     int InvalidEscape = Syntax + Internal + 254;
560     int InvalidInput = Syntax + Internal + 255;
561     int InvalidUnicodeEscape = Syntax + Internal + 256;
562     int InvalidFloat = Syntax + Internal + 257;
563     int NullSourceString = Syntax + Internal + 258;
564     int UnterminatedString = Syntax + Internal + 259;
565     int UnterminatedComment = Syntax + Internal + 260;
566     int NonExternalizedStringLiteral = Internal + 261;
567     /** @since 3.1 */
568     int InvalidDigit = Syntax + Internal + 262;
569     /** @since 3.1 */
570     int InvalidLowSurrogate = Syntax + Internal + 263;
571     /** @since 3.1 */
572     int InvalidHighSurrogate = Syntax + Internal + 264;
573     /** @since 3.2 */
574     int UnnecessaryNLSTag = Internal + 265;
575
576     // type related problems
577 /** @since 3.1 */
578     int DiscouragedReference = TypeRelated + 280;
579
580     int InterfaceCannotHaveInitializers = TypeRelated + 300;
581     int DuplicateModifierForType = TypeRelated + 301;
582     int IllegalModifierForClass = TypeRelated + 302;
583     int IllegalModifierForInterface = TypeRelated + 303;
584     int IllegalModifierForMemberClass = TypeRelated + 304;
585     int IllegalModifierForMemberInterface = TypeRelated + 305;
586     int IllegalModifierForLocalClass = TypeRelated + 306;
587     /** @since 3.1 */
588     int ForbiddenReference = TypeRelated + 307;
589     int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308;
590     int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309;
591     int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310;
592     int IllegalStaticModifierForMemberType = TypeRelated + 311;
593     int SuperclassMustBeAClass = TypeRelated + 312;
594     int ClassExtendFinalClass = TypeRelated + 313;
595     int DuplicateSuperInterface = TypeRelated + 314;
596     int SuperInterfaceMustBeAnInterface = TypeRelated + 315;
597     int HierarchyCircularitySelfReference = TypeRelated + 316;
598     int HierarchyCircularity = TypeRelated + 317;
599     int HidingEnclosingType = TypeRelated + 318;
600     int DuplicateNestedType = TypeRelated + 319;
601     int CannotThrowType = TypeRelated + 320;
602     int PackageCollidesWithType = TypeRelated + 321;
603     int TypeCollidesWithPackage = TypeRelated + 322;
604     int DuplicateTypes = TypeRelated + 323;
605     int IsClassPathCorrect = TypeRelated + 324;
606     int PublicClassMustMatchFileName = TypeRelated + 325;
607     int MustSpecifyPackage = Internal + 326;
608     int HierarchyHasProblems = TypeRelated + 327;
609     int PackageIsNotExpectedPackage = Internal + 328;
610     /** @since 2.1 */
611     int ObjectCannotHaveSuperTypes = Internal + 329;
612     /** @since 3.1 */
613     int ObjectMustBeClass = Internal + 330;
614
615     /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
616     int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
617 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
618     int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
619 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
620     int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
621 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
622     int SuperclassInternalNameProvided = TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
623 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
624     int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
625
626     /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
627     int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
628 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
629     int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
630 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
631     int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
632 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
633     int InterfaceInternalNameProvided = TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
634 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
635     int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
636
637     // field related problems
638 int DuplicateField = FieldRelated + 340;
639     int DuplicateModifierForField = FieldRelated + 341;
640     int IllegalModifierForField = FieldRelated + 342;
641     int IllegalModifierForInterfaceField = FieldRelated + 343;
642     int IllegalVisibilityModifierCombinationForField = FieldRelated + 344;
643     int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345;
644     int UnexpectedStaticModifierForField = FieldRelated + 346;
645
646     /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
647     int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350
648 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
649     int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351
650 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
651     int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352
652 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
653     int FieldTypeInternalNameProvided = FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353
654 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
655     int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349 + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354
656
657     // method related problems
658 int DuplicateMethod = MethodRelated + 355;
659     int IllegalModifierForArgument = MethodRelated + 356;
660     int DuplicateModifierForMethod = MethodRelated + 357;
661     int IllegalModifierForMethod = MethodRelated + 358;
662     int IllegalModifierForInterfaceMethod = MethodRelated + 359;
663     int IllegalVisibilityModifierCombinationForMethod = MethodRelated + 360;
664     int UnexpectedStaticModifierForMethod = MethodRelated + 361;
665     int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
666     int AbstractMethodInAbstractClass = MethodRelated + 363;
667     int ArgumentTypeCannotBeVoid = MethodRelated + 364;
668     /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
669     int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
670     /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
671     int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
672     int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
673     int DuplicateModifierForArgument = MethodRelated + 368;
674
675     /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
676     int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
677 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
678     int ArgumentTypeNotVisible = MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
679 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
680     int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
681 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
682     int ArgumentTypeInternalNameProvided = MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
683 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
684     int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
685
686     /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
687     int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
688 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
689     int ExceptionTypeNotVisible = MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
690 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
691     int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
692 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
693     int ExceptionTypeInternalNameProvided = MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
694 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
695     int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
696
697     /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
698     int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
699 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
700     int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
701 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
702     int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
703 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
704     int ReturnTypeInternalNameProvided = MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
705 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
706     int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
707
708     // import related problems
709 int ConflictingImport = ImportRelated + 385;
710     int DuplicateImport = ImportRelated + 386;
711     int CannotImportPackage = ImportRelated + 387;
712     int UnusedImport = ImportRelated + 388;
713
714     int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
715 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
716     int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
717 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
718     int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
719 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
720     int ImportInternalNameProvided = ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
721 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
722     int ImportInheritedNameHidesEnclosingName = ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
723
724     /** @since 3.1 */
725     int InvalidTypeForStaticImport = ImportRelated + 391;
726
727     // local variable related problems
728 int DuplicateModifierForVariable = MethodRelated + 395;
729     int IllegalModifierForVariable = MethodRelated + 396;
730     /** @deprecated - problem is no longer generated, use {@link #RedundantNullCheckOnNonNullLocalVariable} instead */
731     int LocalVariableCannotBeNull = Internal + 397; // since 3.3: semantics are LocalVariableRedundantCheckOnNonNull
732 /** @deprecated - problem is no longer generated, use {@link #NullLocalVariableReference}, {@link #RedundantNullCheckOnNullLocalVariable} or {@link #RedundantLocalVariableNullAssignment} instead */
733     int LocalVariableCanOnlyBeNull = Internal + 398; // since 3.3: split with LocalVariableRedundantCheckOnNull depending on context
734 /** @deprecated - problem is no longer generated, use {@link #PotentialNullLocalVariableReference} instead */
735     int LocalVariableMayBeNull = Internal + 399;
736
737     // method verifier problems
738 int AbstractMethodMustBeImplemented = MethodRelated + 400;
739     int FinalMethodCannotBeOverridden = MethodRelated + 401;
740     int IncompatibleExceptionInThrowsClause = MethodRelated + 402;
741     int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403;
742     int IncompatibleReturnType = MethodRelated + 404;
743     int InheritedMethodReducesVisibility = MethodRelated + 405;
744     int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406;
745     int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407;
746     int StaticInheritedMethodConflicts = MethodRelated + 408;
747     int MethodReducesVisibility = MethodRelated + 409;
748     int OverridingNonVisibleMethod = MethodRelated + 410;
749     int AbstractMethodCannotBeOverridden = MethodRelated + 411;
750     int OverridingDeprecatedMethod = MethodRelated + 412;
751     /** @since 2.1 */
752     int IncompatibleReturnTypeForNonInheritedInterfaceMethod = MethodRelated + 413;
753     /** @since 2.1 */
754     int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod = MethodRelated + 414;
755     /** @since 3.1 */
756     int IllegalVararg = MethodRelated + 415;
757     /** @since 3.3 */
758     int OverridingMethodWithoutSuperInvocation = MethodRelated + 416;
759     
760     // code snippet support
761 int CodeSnippetMissingClass = Internal + 420;
762     int CodeSnippetMissingMethod = Internal + 421;
763     int CannotUseSuperInCodeSnippet = Internal + 422;
764     
765     //constant pool
766 int TooManyConstantsInConstantPool = Internal + 430;
767     /** @since 2.1 */
768     int TooManyBytesForStringConstant = Internal + 431;
769
770     // static constraints
771 /** @since 2.1 */
772     int TooManyFields = Internal + 432;
773     /** @since 2.1 */
774     int TooManyMethods = Internal + 433;
775         
776     // 1.4 features
777 // assertion warning
778 int UseAssertAsAnIdentifier = Internal + 440;
779     
780     // 1.5 features
781 int UseEnumAsAnIdentifier = Internal + 441;
782     /** @since 3.2 */
783     int EnumConstantsCannotBeSurroundedByParenthesis = Syntax + Internal + 442;
784
785     // detected task
786 /** @since 2.1 */
787     int Task = Internal + 450;
788     
789     // local variables related problems, cont'd
790 /** @since 3.3 */
791     int NullLocalVariableReference = Internal + 451;
792     /** @since 3.3 */
793     int PotentialNullLocalVariableReference = Internal + 452;
794     /** @since 3.3 */
795     int RedundantNullCheckOnNullLocalVariable = Internal + 453;
796     /** @since 3.3 */
797     int NullLocalVariableComparisonYieldsFalse = Internal + 454;
798     /** @since 3.3 */
799     int RedundantLocalVariableNullAssignment = Internal + 455;
800     /** @since 3.3 */
801     int NullLocalVariableInstanceofYieldsFalse = Internal + 456;
802     /** @since 3.3 */
803     int RedundantNullCheckOnNonNullLocalVariable = Internal + 457;
804     /** @since 3.3 */
805     int NonNullLocalVariableComparisonYieldsFalse = Internal + 458;
806
807     // block
808 /** @since 3.0 */
809     int UndocumentedEmptyBlock = Internal + 460;
810         
811     /*
812      * Javadoc comments
813      */
814     /**
815      * Problem warned on duplicated tag.
816      * @since 3.3
817      */
818     int JavadocDuplicateTag = Javadoc + Internal + 464;
819     /**
820      * Problem signaled on an hidden reference due to a too low visibility level.
821      * @since 3.3
822      */
823     int JavadocHiddenReference = Javadoc + Internal + 465;
824     /**
825      * Problem signaled on an invalid qualification for member type reference.
826      * @since 3.3
827      */
828     int JavadocInvalidMemberTypeQualification = Javadoc + Internal + 466;
829     /** @since 3.2 */
830     int JavadocMissingIdentifier = Javadoc + Internal + 467;
831     /** @since 3.2 */
832     int JavadocNonStaticTypeFromStaticInvocation = Javadoc + Internal + 468;
833     /** @since 3.1 */
834     int JavadocInvalidParamTagTypeParameter = Javadoc + Internal + 469;
835     /** @since 3.0 */
836     int JavadocUnexpectedTag = Javadoc + Internal + 470;
837     /** @since 3.0 */
838     int JavadocMissingParamTag = Javadoc + Internal + 471;
839     /** @since 3.0 */
840     int JavadocMissingParamName = Javadoc + Internal + 472;
841     /** @since 3.0 */
842     int JavadocDuplicateParamName = Javadoc + Internal + 473;
843     /** @since 3.0 */
844     int JavadocInvalidParamName = Javadoc + Internal + 474;
845     /** @since 3.0 */
846     int JavadocMissingReturnTag = Javadoc + Internal + 475;
847     /** @since 3.0 */
848     int JavadocDuplicateReturnTag = Javadoc + Internal + 476;
849     /** @since 3.0 */
850     int JavadocMissingThrowsTag = Javadoc + Internal + 477;
851     /** @since 3.0 */
852     int JavadocMissingThrowsClassName = Javadoc + Internal + 478;
853     /** @since 3.0 */
854     int JavadocInvalidThrowsClass = Javadoc + Internal + 479;
855     /** @since 3.0 */
856     int JavadocDuplicateThrowsClassName = Javadoc + Internal + 480;
857     /** @since 3.0 */
858     int JavadocInvalidThrowsClassName = Javadoc + Internal + 481;
859     /** @since 3.0 */
860     int JavadocMissingSeeReference = Javadoc + Internal + 482;
861     /** @since 3.0 */
862     int JavadocInvalidSeeReference = Javadoc + Internal + 483;
863     /** @since 3.0 */
864     int JavadocInvalidSeeHref = Javadoc + Internal + 484;
865     /** @since 3.0 */
866     int JavadocInvalidSeeArgs = Javadoc + Internal + 485;
867     /** @since 3.0 */
868     int JavadocMissing = Javadoc + Internal + 486;
869     /** @since 3.0 */
870     int JavadocInvalidTag = Javadoc + Internal + 487;
871     /*
872      * ID for field errors in Javadoc
873      */
874     /** @since 3.0 */
875     int JavadocUndefinedField = Javadoc + Internal + 488;
876     /** @since 3.0 */
877     int JavadocNotVisibleField = Javadoc + Internal + 489;
878     /** @since 3.0 */
879     int JavadocAmbiguousField = Javadoc + Internal + 490;
880     /** @since 3.0 */
881     int JavadocUsingDeprecatedField = Javadoc + Internal + 491;
882     /*
883      * IDs for constructor errors in Javadoc
884      */
885     /** @since 3.0 */
886     int JavadocUndefinedConstructor = Javadoc + Internal + 492;
887     /** @since 3.0 */
888     int JavadocNotVisibleConstructor = Javadoc + Internal + 493;
889     /** @since 3.0 */
890     int JavadocAmbiguousConstructor = Javadoc + Internal + 494;
891     /** @since 3.0 */
892     int JavadocUsingDeprecatedConstructor = Javadoc + Internal + 495;
893     /*
894      * IDs for method errors in Javadoc
895      */
896     /** @since 3.0 */
897     int JavadocUndefinedMethod = Javadoc + Internal + 496;
898     /** @since 3.0 */
899     int JavadocNotVisibleMethod = Javadoc + Internal + 497;
900     /** @since 3.0 */
901     int JavadocAmbiguousMethod = Javadoc + Internal + 498;
902     /** @since 3.0 */
903     int JavadocUsingDeprecatedMethod = Javadoc + Internal + 499;
904     /** @since 3.0 */
905     int JavadocNoMessageSendOnBaseType = Javadoc + Internal + 500;
906     /** @since 3.0 */
907     int JavadocParameterMismatch = Javadoc + Internal + 501;
908     /** @since 3.0 */
909     int JavadocNoMessageSendOnArrayType = Javadoc + Internal + 502;
910     /*
911      * IDs for type errors in Javadoc
912      */
913     /** @since 3.0 */
914     int JavadocUndefinedType = Javadoc + Internal + 503;
915     /** @since 3.0 */
916     int JavadocNotVisibleType = Javadoc + Internal + 504;
917     /** @since 3.0 */
918     int JavadocAmbiguousType = Javadoc + Internal + 505;
919     /** @since 3.0 */
920     int JavadocUsingDeprecatedType = Javadoc + Internal + 506;
921     /** @since 3.0 */
922     int JavadocInternalTypeNameProvided = Javadoc + Internal + 507;
923     /** @since 3.0 */
924     int JavadocInheritedMethodHidesEnclosingName = Javadoc + Internal + 508;
925     /** @since 3.0 */
926     int JavadocInheritedFieldHidesEnclosingName = Javadoc + Internal + 509;
927     /** @since 3.0 */
928     int JavadocInheritedNameHidesEnclosingTypeName = Javadoc + Internal + 510;
929     /** @since 3.0 */
930     int JavadocAmbiguousMethodReference = Javadoc + Internal + 511;
931     /** @since 3.0 */
932     int JavadocUnterminatedInlineTag = Javadoc + Internal + 512;
933     /** @since 3.0 */
934     int JavadocMalformedSeeReference = Javadoc + Internal + 513;
935     /** @since 3.0 */
936     int JavadocMessagePrefix = Internal + 514;
937
938     /** @since 3.1 */
939     int JavadocMissingHashCharacter = Javadoc + Internal + 515;
940     /** @since 3.1 */
941     int JavadocEmptyReturnTag = Javadoc + Internal + 516;
942     /** @since 3.1 */
943     int JavadocInvalidValueReference = Javadoc + Internal + 517;
944     /** @since 3.1 */
945     int JavadocUnexpectedText = Javadoc + Internal + 518;
946     /** @since 3.1 */
947     int JavadocInvalidParamTagName = Javadoc + Internal + 519;
948
949     /**
950      * Generics
951      */
952     /** @since 3.1 */
953     int DuplicateTypeVariable = Internal + 520;
954     /** @since 3.1 */
955     int IllegalTypeVariableSuperReference = Internal + 521;
956     /** @since 3.1 */
957     int NonStaticTypeFromStaticInvocation = Internal + 522;
958     /** @since 3.1 */
959     int ObjectCannotBeGeneric = Internal + 523;
960     /** @since 3.1 */
961     int NonGenericType = TypeRelated + 524;
962     /** @since 3.1 */
963     int IncorrectArityForParameterizedType = TypeRelated + 525;
964     /** @since 3.1 */
965     int TypeArgumentMismatch = TypeRelated + 526;
966     /** @since 3.1 */
967     int DuplicateMethodErasure = TypeRelated + 527;
968     /** @since 3.1 */
969     int ReferenceToForwardTypeVariable = TypeRelated + 528;
970     /** @since 3.1 */
971     int BoundMustBeAnInterface = TypeRelated + 529;
972     /** @since 3.1 */
973     int UnsafeRawConstructorInvocation = TypeRelated + 530;
974     /** @since 3.1 */
975     int UnsafeRawMethodInvocation = TypeRelated + 531;
976     /** @since 3.1 */
977     int UnsafeTypeConversion = TypeRelated + 532;
978     /** @since 3.1 */
979     int InvalidTypeVariableExceptionType = TypeRelated + 533;
980     /** @since 3.1 */
981     int InvalidParameterizedExceptionType = TypeRelated + 534;
982     /** @since 3.1 */
983     int IllegalGenericArray = TypeRelated + 535;
984     /** @since 3.1 */
985     int UnsafeRawFieldAssignment = TypeRelated + 536;
986     /** @since 3.1 */
987     int FinalBoundForTypeVariable = TypeRelated + 537;
988     /** @since 3.1 */
989     int UndefinedTypeVariable = Internal + 538;
990     /** @since 3.1 */
991     int SuperInterfacesCollide = TypeRelated + 539;
992     /** @since 3.1 */
993     int WildcardConstructorInvocation = TypeRelated + 540;
994     /** @since 3.1 */
995     int WildcardMethodInvocation = TypeRelated + 541;
996     /** @since 3.1 */
997     int WildcardFieldAssignment = TypeRelated + 542;
998     /** @since 3.1 */
999     int GenericMethodTypeArgumentMismatch = TypeRelated + 543;
1000    /** @since 3.1 */
1001    int GenericConstructorTypeArgumentMismatch = TypeRelated + 544;
1002    /** @since 3.1 */
1003    int UnsafeGenericCast = TypeRelated + 545;
1004    /** @since 3.1 */
1005    int IllegalInstanceofParameterizedType = Internal + 546;
1006    /** @since 3.1 */
1007    int IllegalInstanceofTypeParameter = Internal + 547;
1008    /** @since 3.1 */
1009    int NonGenericMethod = TypeRelated + 548;
1010    /** @since 3.1 */
1011    int IncorrectArityForParameterizedMethod = TypeRelated + 549;
1012    /** @since 3.1 */
1013    int ParameterizedMethodArgumentTypeMismatch = TypeRelated + 550;
1014    /** @since 3.1 */
1015    int NonGenericConstructor = TypeRelated + 551;
1016    /** @since 3.1 */
1017    int IncorrectArityForParameterizedConstructor = TypeRelated + 552;
1018    /** @since 3.1 */
1019    int ParameterizedConstructorArgumentTypeMismatch = TypeRelated + 553;
1020    /** @since 3.1 */
1021    int TypeArgumentsForRawGenericMethod = TypeRelated + 554;
1022    /** @since 3.1 */
1023    int TypeArgumentsForRawGenericConstructor = TypeRelated + 555;
1024    /** @since 3.1 */
1025    int SuperTypeUsingWildcard = TypeRelated + 556;
1026    /** @since 3.1 */
1027    int GenericTypeCannotExtendThrowable = TypeRelated + 557;
1028    /** @since 3.1 */
1029    int IllegalClassLiteralForTypeVariable = TypeRelated + 558;
1030    /** @since 3.1 */
1031    int UnsafeReturnTypeOverride = MethodRelated + 559;
1032    /** @since 3.1 */
1033    int MethodNameClash = MethodRelated + 560;
1034    /** @since 3.1 */
1035    int RawMemberTypeCannotBeParameterized = TypeRelated + 561;
1036    /** @since 3.1 */
1037    int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;
1038    /** @since 3.1 */
1039    int StaticMemberOfParameterizedType = TypeRelated + 563;
1040    /** @since 3.1 */
1041    int BoundHasConflictingArguments = TypeRelated + 564;
1042    /** @since 3.1 */
1043    int DuplicateParameterizedMethods = MethodRelated + 565;
1044    /** @since 3.1 */
1045    int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;
1046    /** @since 3.1 */
1047    int DuplicateBounds = TypeRelated + 567;
1048    /** @since 3.1 */
1049    int BoundCannotBeArray = TypeRelated + 568;
1050    /** @since 3.1 */
1051    int UnsafeRawGenericConstructorInvocation = TypeRelated + 569;
1052    /** @since 3.1 */
1053    int UnsafeRawGenericMethodInvocation = TypeRelated + 570;
1054    /** @since 3.1 */
1055    int TypeParameterHidingType = TypeRelated + 571;
1056    /** @since 3.2 */
1057    int RawTypeReference = TypeRelated + 572;
1058    /** @since 3.2 */
1059    int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;
1060    /** @since 3.2 */
1061    int UnsafeGenericArrayForVarargs = MethodRelated + 574;
1062    /** @since 3.2 */
1063    int IllegalAccessFromTypeVariable = TypeRelated + 575;
1064    /** @since 3.3 */
1065    int TypeHidingTypeParameterFromType = TypeRelated + 576;
1066    /** @since 3.3 */
1067    int TypeHidingTypeParameterFromMethod = TypeRelated + 577;
1068    /** @since 3.3 */
1069    int InvalidUsageOfWildcard = Syntax + Internal + 578;
1070    
1071    /**
1072     * Foreach
1073     */
1074    /** @since 3.1 */
1075    int IncompatibleTypesInForeach = TypeRelated + 580;
1076    /** @since 3.1 */
1077    int InvalidTypeForCollection = Internal + 581;
1078    
1079    /**
1080     * 1.5 Syntax errors (when source level < 1.5)
1081     */
1082    /** @since 3.1 */
1083    int InvalidUsageOfTypeParameters = Syntax + Internal + 590;
1084    /** @since 3.1 */
1085    int InvalidUsageOfStaticImports = Syntax + Internal + 591;
1086    /** @since 3.1 */
1087    int InvalidUsageOfForeachStatements = Syntax + Internal + 592;
1088    /** @since 3.1 */
1089    int InvalidUsageOfTypeArguments = Syntax + Internal + 593;
1090    /** @since 3.1 */
1091    int InvalidUsageOfEnumDeclarations = Syntax + Internal + 594;
1092    /** @since 3.1 */
1093    int InvalidUsageOfVarargs = Syntax + Internal + 595;
1094    /** @since 3.1 */
1095    int InvalidUsageOfAnnotations = Syntax + Internal + 596;
1096    /** @since 3.1 */
1097    int InvalidUsageOfAnnotationDeclarations = Syntax + Internal + 597;
1098    
1099    /**
1100     * Annotation
1101     */
1102    /** @since 3.1 */
1103    int IllegalModifierForAnnotationMethod = MethodRelated + 600;
1104    /** @since 3.1 */
1105    int IllegalExtendedDimensions = MethodRelated + 601;
1106    /** @since 3.1 */
1107    int InvalidFileNameForPackageAnnotations = Syntax + Internal + 602;
1108    /** @since 3.1 */
1109    int IllegalModifierForAnnotationType = TypeRelated + 603;
1110    /** @since 3.1 */
1111    int IllegalModifierForAnnotationMemberType = TypeRelated + 604;
1112    /** @since 3.1 */
1113    int InvalidAnnotationMemberType = TypeRelated + 605;
1114    /** @since 3.1 */
1115    int AnnotationCircularitySelfReference = TypeRelated + 606;
1116    /** @since 3.1 */
1117    int AnnotationCircularity = TypeRelated + 607;
1118    /** @since 3.1 */
1119    int DuplicateAnnotation = TypeRelated + 608;
1120    /** @since 3.1 */
1121    int MissingValueForAnnotationMember = TypeRelated + 609;
1122    /** @since 3.1 */
1123    int DuplicateAnnotationMember = Internal + 610;
1124    /** @since 3.1 */
1125    int UndefinedAnnotationMember = MethodRelated + 611;
1126    /** @since 3.1 */
1127    int AnnotationValueMustBeClassLiteral = Internal + 612;
1128    /** @since 3.1 */
1129    int AnnotationValueMustBeConstant = Internal + 613;
1130    /** @deprecated - problem is no longer generated (code is legite)
1131     * @since 3.1 */
1132    int AnnotationFieldNeedConstantInitialization = Internal + 614;
1133    /** @since 3.1 */
1134    int IllegalModifierForAnnotationField = Internal + 615;
1135    /** @since 3.1 */
1136    int AnnotationCannotOverrideMethod = MethodRelated + 616;
1137    /** @since 3.1 */
1138    int AnnotationMembersCannotHaveParameters = Syntax + Internal + 617;
1139    /** @since 3.1 */
1140    int AnnotationMembersCannotHaveTypeParameters = Syntax + Internal + 618;
1141    /** @since 3.1 */
1142    int AnnotationTypeDeclarationCannotHaveSuperclass = Syntax + Internal + 619;
1143    /** @since 3.1 */
1144    int AnnotationTypeDeclarationCannotHaveSuperinterfaces = Syntax + Internal + 620;
1145    /** @since 3.1 */
1146    int DuplicateTargetInTargetAnnotation = Internal + 621;
1147    /** @since 3.1 */
1148    int DisallowedTargetForAnnotation = TypeRelated + 622;
1149    /** @since 3.1 */
1150    int MethodMustOverride = MethodRelated + 623;
1151    /** @since 3.1 */
1152    int AnnotationTypeDeclarationCannotHaveConstructor = Syntax + Internal + 624;
1153    /** @since 3.1 */
1154    int AnnotationValueMustBeAnnotation = Internal + 625;
1155    /** @since 3.1 */
1156    int AnnotationTypeUsedAsSuperInterface = TypeRelated + 626;
1157    /** @since 3.1 */
1158    int MissingOverrideAnnotation = MethodRelated + 627;
1159    /** @since 3.1 */
1160    int FieldMissingDeprecatedAnnotation = Internal + 628;
1161    /** @since 3.1 */
1162    int MethodMissingDeprecatedAnnotation = Internal + 629;
1163    /** @since 3.1 */
1164    int TypeMissingDeprecatedAnnotation = Internal + 630;
1165    /** @since 3.1 */
1166    int UnhandledWarningToken = Internal + 631;
1167    /** @since 3.2 */
1168    int AnnotationValueMustBeArrayInitializer = Internal + 632;
1169    /** @since 3.3 */
1170    int AnnotationValueMustBeAnEnumConstant = Internal + 633;
1171    /** @since 3.3 */
1172    int MethodMustOverrideOrImplement = MethodRelated + 634;
1173    
1174    /**
1175     * Corrupted binaries
1176     */
1177    /** @since 3.1 */
1178    int CorruptedSignature = Internal + 700;
1179    /**
1180     * Corrupted source
1181     */
1182    /** @since 3.2 */
1183    int InvalidEncoding = Internal + 701;
1184    /** @since 3.2 */
1185    int CannotReadSource = Internal + 702;
1186
1187    /**
1188     * Autoboxing
1189     */
1190    /** @since 3.1 */
1191    int BoxingConversion = Internal + 720;
1192    /** @since 3.1 */
1193    int UnboxingConversion = Internal + 721;
1194    
1195    /**
1196     * Enum
1197     */
1198    /** @since 3.1 */
1199    int IllegalModifierForEnum = TypeRelated + 750;
1200    /** @since 3.1 */
1201    int IllegalModifierForEnumConstant = FieldRelated + 751;
1202    /** @since 3.1 */
1203    int IllegalModifierForLocalEnum = TypeRelated + 752;
1204    /** @since 3.1 */
1205    int IllegalModifierForMemberEnum = TypeRelated + 753;
1206    /** @since 3.1 */
1207    int CannotDeclareEnumSpecialMethod = MethodRelated + 754;
1208    /** @since 3.1 */
1209    int IllegalQualifiedEnumConstantLabel = FieldRelated + 755;
1210    /** @since 3.1 */
1211    int CannotExtendEnum = TypeRelated + 756;
1212    /** @since 3.1 */
1213    int CannotInvokeSuperConstructorInEnum = MethodRelated + 757;
1214    /** @since 3.1 */
1215    int EnumAbstractMethodMustBeImplemented = MethodRelated + 758;
1216    /** @since 3.1 */
1217    int EnumSwitchCannotTargetField = FieldRelated + 759;
1218    /** @since 3.1 */
1219    int IllegalModifierForEnumConstructor = MethodRelated + 760;
1220    /** @since 3.1 */
1221    int MissingEnumConstantCase = FieldRelated + 761;
1222    /** @since 3.2 */ // TODO need to fix 3.1.1 contribution (inline this constant on client side)
1223 int EnumStaticFieldInInInitializerContext = FieldRelated + 762;
1224    
1225    /**
1226     * Var args
1227     */
1228    /** @since 3.1 */
1229    int IllegalExtendedDimensionsForVarArgs = Syntax + Internal + 800;
1230    /** @since 3.1 */
1231    int MethodVarargsArgumentNeedCast = MethodRelated + 801;
1232    /** @since 3.1 */
1233    int ConstructorVarargsArgumentNeedCast = ConstructorRelated + 802;
1234    /** @since 3.1 */
1235    int VarargsConflict = MethodRelated + 803;
1236    
1237    /**
1238     * Javadoc Generic
1239     */
1240    /** @since 3.1 */
1241    int JavadocGenericMethodTypeArgumentMismatch = Javadoc + Internal + 850;
1242    /** @since 3.1 */
1243    int JavadocNonGenericMethod = Javadoc + Internal + 851;
1244    /** @since 3.1 */
1245    int JavadocIncorrectArityForParameterizedMethod = Javadoc + Internal + 852;
1246    /** @since 3.1 */
1247    int JavadocParameterizedMethodArgumentTypeMismatch = Javadoc + Internal + 853;
1248    /** @since 3.1 */
1249    int JavadocTypeArgumentsForRawGenericMethod = Javadoc + Internal + 854;
1250    /** @since 3.1 */
1251    int JavadocGenericConstructorTypeArgumentMismatch = Javadoc + Internal + 855;
1252    /** @since 3.1 */
1253    int JavadocNonGenericConstructor = Javadoc + Internal + 856;
1254    /** @since 3.1 */
1255    int JavadocIncorrectArityForParameterizedConstructor = Javadoc + Internal + 857;
1256    /** @since 3.1 */
1257    int JavadocParameterizedConstructorArgumentTypeMismatch = Javadoc + Internal + 858;
1258    /** @since 3.1 */
1259    int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;
1260
1261    /**
1262     * External problems -- These are problems defined by other plugins
1263     */
1264
1265    /** @since 3.2 */
1266    int ExternalProblemNotFixable = 900;
1267
1268    // indicates an externally defined problem that has a quick-assist processor
1269 // associated with it
1270 /** @since 3.2 */
1271    int ExternalProblemFixable = 901;
1272}
1273
Popular Tags