1 /*******************************************************************************
2 * Copyright (c) 2000, 2020 IBM Corporation and others.
3 *
4 * This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License 2.0
6 * which accompanies this distribution, and is available at
7 * https://www.eclipse.org/legal/epl-2.0/
8 *
9 * SPDX-License-Identifier: EPL-2.0
10 *
11 * Contributors:
12 * IBM Corporation - initial API and implementation
13 * IBM Corporation - added the following constants
14 * NonStaticAccessToStaticField
15 * NonStaticAccessToStaticMethod
16 * Task
17 * ExpressionShouldBeAVariable
18 * AssignmentHasNoEffect
19 * IBM Corporation - added the following constants
20 * TooManySyntheticArgumentSlots
21 * TooManyArrayDimensions
22 * TooManyBytesForStringConstant
23 * TooManyMethods
24 * TooManyFields
25 * NonBlankFinalLocalAssignment
26 * ObjectCannotHaveSuperTypes
27 * MissingSemiColon
28 * InvalidParenthesizedExpression
29 * EnclosingInstanceInConstructorCall
30 * BytecodeExceeds64KLimitForConstructor
31 * IncompatibleReturnTypeForNonInheritedInterfaceMethod
32 * UnusedPrivateMethod
33 * UnusedPrivateConstructor
34 * UnusedPrivateType
35 * UnusedPrivateField
36 * IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod
37 * InvalidExplicitConstructorCall
38 * IBM Corporation - added the following constants
39 * PossibleAccidentalBooleanAssignment
40 * SuperfluousSemicolon
41 * IndirectAccessToStaticField
42 * IndirectAccessToStaticMethod
43 * IndirectAccessToStaticType
44 * BooleanMethodThrowingException
45 * UnnecessaryCast
46 * UnnecessaryArgumentCast
47 * UnnecessaryInstanceof
48 * FinallyMustCompleteNormally
49 * UnusedMethodDeclaredThrownException
50 * UnusedConstructorDeclaredThrownException
51 * InvalidCatchBlockSequence
52 * UnqualifiedFieldAccess
53 * IBM Corporation - added the following constants
54 * Javadoc
55 * JavadocUnexpectedTag
56 * JavadocMissingParamTag
57 * JavadocMissingParamName
58 * JavadocDuplicateParamName
59 * JavadocInvalidParamName
60 * JavadocMissingReturnTag
61 * JavadocDuplicateReturnTag
62 * JavadocMissingThrowsTag
63 * JavadocMissingThrowsClassName
64 * JavadocInvalidThrowsClass
65 * JavadocDuplicateThrowsClassName
66 * JavadocInvalidThrowsClassName
67 * JavadocMissingSeeReference
68 * JavadocInvalidSeeReference
69 * JavadocInvalidSeeHref
70 * JavadocInvalidSeeArgs
71 * JavadocMissing
72 * JavadocInvalidTag
73 * JavadocMessagePrefix
74 * EmptyControlFlowStatement
75 * IBM Corporation - added the following constants
76 * IllegalUsageOfQualifiedTypeReference
77 * InvalidDigit
78 * IBM Corporation - added the following constants
79 * ParameterAssignment
80 * FallthroughCase
81 * IBM Corporation - added the following constants
82 * UnusedLabel
83 * UnnecessaryNLSTag
84 * LocalVariableMayBeNull
85 * EnumConstantsCannotBeSurroundedByParenthesis
86 * JavadocMissingIdentifier
87 * JavadocNonStaticTypeFromStaticInvocation
88 * RawTypeReference
89 * NoAdditionalBoundAfterTypeVariable
90 * UnsafeGenericArrayForVarargs
91 * IllegalAccessFromTypeVariable
92 * AnnotationValueMustBeArrayInitializer
93 * InvalidEncoding
94 * CannotReadSource
95 * EnumStaticFieldInInInitializerContext
96 * ExternalProblemNotFixable
97 * ExternalProblemFixable
98 * IBM Corporation - added the following constants
99 * AnnotationValueMustBeAnEnumConstant
100 * OverridingMethodWithoutSuperInvocation
101 * MethodMustOverrideOrImplement
102 * TypeHidingTypeParameterFromType
103 * TypeHidingTypeParameterFromMethod
104 * TypeHidingType
105 * IBM Corporation - added the following constants
106 * NullLocalVariableReference
107 * PotentialNullLocalVariableReference
108 * RedundantNullCheckOnNullLocalVariable
109 * NullLocalVariableComparisonYieldsFalse
110 * RedundantLocalVariableNullAssignment
111 * NullLocalVariableInstanceofYieldsFalse
112 * RedundantNullCheckOnNonNullLocalVariable
113 * NonNullLocalVariableComparisonYieldsFalse
114 * IBM Corporation - added the following constants
115 * InvalidUsageOfTypeParametersForAnnotationDeclaration
116 * InvalidUsageOfTypeParametersForEnumDeclaration
117 * IBM Corporation - added the following constants
118 * RedundantSuperinterface
119 * Benjamin Muskalla - added the following constants
120 * MissingSynchronizedModifierInInheritedMethod
121 * Stephan Herrmann - added the following constants
122 * UnusedObjectAllocation
123 * PotentiallyUnclosedCloseable
124 * PotentiallyUnclosedCloseableAtExit
125 * UnclosedCloseable
126 * UnclosedCloseableAtExit
127 * ExplicitlyClosedAutoCloseable
128 * RequiredNonNullButProvidedNull
129 * RequiredNonNullButProvidedPotentialNull
130 * RequiredNonNullButProvidedUnknown
131 * NullAnnotationNameMustBeQualified
132 * IllegalReturnNullityRedefinition
133 * IllegalRedefinitionToNonNullParameter
134 * IllegalDefinitionToNonNullParameter
135 * ParameterLackingNonNullAnnotation
136 * ParameterLackingNullableAnnotation
137 * PotentialNullMessageSendReference
138 * RedundantNullCheckOnNonNullMessageSend
139 * CannotImplementIncompatibleNullness
140 * RedundantNullAnnotation
141 * RedundantNullDefaultAnnotation
142 * RedundantNullDefaultAnnotationPackage
143 * RedundantNullDefaultAnnotationType
144 * RedundantNullDefaultAnnotationMethod
145 * ContradictoryNullAnnotations
146 * IllegalAnnotationForBaseType
147 * RedundantNullCheckOnSpecdNonNullLocalVariable
148 * SpecdNonNullLocalVariableComparisonYieldsFalse
149 * RequiredNonNullButProvidedSpecdNullable
150 * MissingDefaultCase
151 * MissingEnumConstantCaseDespiteDefault
152 * UninitializedLocalVariableHintMissingDefault
153 * UninitializedBlankFinalFieldHintMissingDefault
154 * ShouldReturnValueHintMissingDefault
155 * IllegalModifierForInterfaceDefaultMethod
156 * InheritedDefaultMethodConflictsWithOtherInherited
157 * ConflictingNullAnnotations
158 * ConflictingInheritedNullAnnotations
159 * UnsafeElementTypeConversion
160 * ArrayReferencePotentialNullReference
161 * DereferencingNullableExpression
162 * NullityMismatchingTypeAnnotation
163 * NullityMismatchingTypeAnnotationSuperHint
164 * NullityUncheckedTypeAnnotationDetail
165 * NullityUncheckedTypeAnnotationDetailSuperHint
166 * NullableFieldReference
167 * UninitializedNonNullField
168 * UninitializedNonNullFieldHintMissingDefault
169 * NonNullMessageSendComparisonYieldsFalse
170 * RedundantNullCheckOnNonNullSpecdField
171 * NonNullSpecdFieldComparisonYieldsFalse
172 * NonNullExpressionComparisonYieldsFalse
173 * RedundantNullCheckOnNonNullExpression
174 * ReferenceExpressionParameterNullityMismatch
175 * ReferenceExpressionParameterNullityUnchecked
176 * ReferenceExpressionReturnNullRedef
177 * ReferenceExpressionReturnNullRedefUnchecked
178 * DuplicateInheritedDefaultMethods
179 * SuperAccessCannotBypassDirectSuper
180 * SuperCallCannotBypassOverride
181 * ConflictingNullAnnotations
182 * ConflictingInheritedNullAnnotations
183 * UnsafeElementTypeConversion
184 * PotentialNullUnboxing
185 * NullUnboxing
186 * NullExpressionReference
187 * PotentialNullExpressionReference
188 * RedundantNullCheckAgainstNonNullType
189 * NullAnnotationUnsupportedLocation
190 * NullAnnotationUnsupportedLocationAtType
191 * NullityMismatchTypeArgument
192 * ContradictoryNullAnnotationsOnBound
193 * UnsafeNullnessCast
194 * ContradictoryNullAnnotationsInferred
195 * NonNullDefaultDetailIsNotEvaluated
196 * NullNotCompatibleToFreeTypeVariable
197 * NullityMismatchAgainstFreeTypeVariable
198 * ImplicitObjectBoundNoNullDefault
199 * IllegalParameterNullityRedefinition
200 * ContradictoryNullAnnotationsInferredFunctionType
201 * IllegalReturnNullityRedefinitionFreeTypeVariable
202 * UnlikelyCollectionMethodArgumentType
203 * UnlikelyEqualsArgumentType
204 * Jesper S Moller - added the following constants
205 * TargetTypeNotAFunctionalInterface
206 * OuterLocalMustBeEffectivelyFinal
207 * IllegalModifiersForPackage
208 * DuplicateAnnotationNotMarkedRepeatable
209 * DisallowedTargetForContainerAnnotation
210 * RepeatedAnnotationWithContainerAnnotation
211 * ContainingAnnotationMustHaveValue
212 * ContainingAnnotationHasNonDefaultMembers
213 * ContainingAnnotationHasWrongValueType
214 * ContainingAnnotationHasShorterRetention
215 * RepeatableAnnotationHasTargets
216 * RepeatableAnnotationTargetMismatch
217 * RepeatableAnnotationIsDocumented
218 * RepeatableAnnotationIsInherited
219 * RepeatableAnnotationWithRepeatingContainerAnnotation
220 * VarLocalMultipleDeclarators
221 * VarLocalCannotBeArray
222 * VarLocalReferencesItself
223 * VarLocalWithoutInitizalier
224 * VarLocalInitializedToNull
225 * VarLocalCannotBeArrayInitalizers
226 * VarLocalCannotBeLambda
227 * VarLocalCannotBeMethodReference
228 * VarIsReserved
229 * VarIsReservedInFuture
230 * VarIsNotAllowedHere
231 ******************************************************************************/
232 package org.eclipse.jdt.core.compiler;
233
234 import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
235
236 /**
237 * Description of a Java problem, as detected by the compiler or some of the underlying
238 * technology reusing the compiler.
239 * A problem provides access to:
240 * <ul>
241 * <li> its location (originating source file name, source position, line number) </li>
242 * <li> its message description </li>
243 * <li> predicates to check its severity (error, warning, or info) </li>
244 * <li> its ID : a number identifying the very nature of this problem. All possible IDs are listed
245 * as constants on this interface. </li>
246 * </ul>
247 *
248 * Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder
249 * so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected
250 * when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular
251 * their ID (attribute "id") is set to one of the IDs defined on this interface.
252 *
253 * @since 2.0
254 * @noimplement This interface is not intended to be implemented by clients.
255 * @noextend This interface is not intended to be extended by clients.
256 */
257 public interface IProblem {
258
259 /**
260 * Answer back the original arguments recorded into the problem.
261 * @return the original arguments recorded into the problem
262 */
getArguments()263 String[] getArguments();
264
265 /**
266 * Returns the problem id
267 *
268 * @return the problem id
269 */
getID()270 int getID();
271
272 /**
273 * Answer a localized, human-readable message string which describes the problem.
274 *
275 * @return a localized, human-readable message string which describes the problem
276 */
getMessage()277 String getMessage();
278
279 /**
280 * Answer the file name in which the problem was found.
281 *
282 * @return the file name in which the problem was found
283 */
getOriginatingFileName()284 char[] getOriginatingFileName();
285
286 /**
287 * Answer the end position of the problem (inclusive), or -1 if unknown.
288 *
289 * @return the end position of the problem (inclusive), or -1 if unknown
290 */
getSourceEnd()291 int getSourceEnd();
292
293 /**
294 * Answer the line number in source where the problem begins.
295 *
296 * @return the line number in source where the problem begins
297 */
getSourceLineNumber()298 int getSourceLineNumber();
299
300 /**
301 * Answer the start position of the problem (inclusive), or -1 if unknown.
302 *
303 * @return the start position of the problem (inclusive), or -1 if unknown
304 */
getSourceStart()305 int getSourceStart();
306
307 /**
308 * Returns whether the severity of this problem is 'Error'.
309 *
310 * @return true if the severity of this problem is 'Error', false otherwise
311 */
isError()312 boolean isError();
313
314 /**
315 * Returns whether the severity of this problem is 'Warning'.
316 *
317 * @return true if the severity of this problem is 'Warning', false otherwise
318 */
isWarning()319 boolean isWarning();
320
321 /**
322 * Returns whether the severity of this problem is 'Info'.
323 *
324 * @return true if the severity of this problem is 'Info', false otherwise
325 * @since 3.12
326 */
isInfo()327 boolean isInfo();
328
329 /**
330 * Set the end position of the problem (inclusive), or -1 if unknown.
331 * Used for shifting problem positions.
332 *
333 * @param sourceEnd the given end position
334 */
setSourceEnd(int sourceEnd)335 void setSourceEnd(int sourceEnd);
336
337 /**
338 * Set the line number in source where the problem begins.
339 *
340 * @param lineNumber the given line number
341 */
setSourceLineNumber(int lineNumber)342 void setSourceLineNumber(int lineNumber);
343
344 /**
345 * Set the start position of the problem (inclusive), or -1 if unknown.
346 * Used for shifting problem positions.
347 *
348 * @param sourceStart the given start position
349 */
setSourceStart(int sourceStart)350 void setSourceStart(int sourceStart);
351
352
353 /**
354 * Problem Categories
355 * The high bits of a problem ID contains information about the category of a problem.
356 * For example, (problemID & TypeRelated) != 0, indicates that this problem is type related.
357 *
358 * A problem category can help to implement custom problem filters. Indeed, when numerous problems
359 * are listed, focusing on import related problems first might be relevant.
360 *
361 * When a problem is tagged as Internal, it means that no change other than a local source code change
362 * can fix the corresponding problem. A type related problem could be addressed by changing the type
363 * involved in it.
364 */
365 int TypeRelated = 0x01000000;
366 int FieldRelated = 0x02000000;
367 int MethodRelated = 0x04000000;
368 int ConstructorRelated = 0x08000000;
369 int ImportRelated = 0x10000000;
370 int Internal = 0x20000000;
371 int Syntax = 0x40000000;
372 /** @since 3.0 */
373 int Javadoc = 0x80000000;
374 /** @since 3.14 */
375 int ModuleRelated = 0x00800000;
376 /** @since 3.18 */
377 int Compliance = 0x00400000;
378 /** @since 3.20 */
379 int PreviewRelated = 0x00200000;
380
381 /**
382 * Mask to use in order to filter out the category portion of the problem ID.
383 */
384 int IgnoreCategoriesMask = 0x1FFFFF;
385
386 /*
387 * Below are listed all available problem IDs. Note that this list could be augmented in the future,
388 * as new features are added to the Java core implementation.
389 *
390 * Problem IDs must be kept unique even when their mask is stripped, since
391 * the bare integer literal is used for message lookup in
392 * /org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties.
393 * Use this regex to find duplicates: (?s)(\+ \d+)\b.*\1\b
394 */
395
396 /**
397 * ID reserved for referencing an internal error inside the JavaCore implementation which
398 * may be surfaced as a problem associated with the compilation unit which caused it to occur.
399 */
400 int Unclassified = 0;
401
402 /**
403 * General type related problems
404 */
405 int ObjectHasNoSuperclass = TypeRelated + 1;
406 int UndefinedType = TypeRelated + 2;
407 int NotVisibleType = TypeRelated + 3;
408 int AmbiguousType = TypeRelated + 4;
409 int UsingDeprecatedType = TypeRelated + 5;
410 int InternalTypeNameProvided = TypeRelated + 6;
411 /** @since 2.1 */
412 int UnusedPrivateType = Internal + TypeRelated + 7;
413
414 int IncompatibleTypesInEqualityOperator = TypeRelated + 15;
415 int IncompatibleTypesInConditionalOperator = TypeRelated + 16;
416 int TypeMismatch = TypeRelated + 17;
417 /** @since 3.0 */
418 int IndirectAccessToStaticType = Internal + TypeRelated + 18;
419
420 /** @since 3.10 */
421 int ReturnTypeMismatch = TypeRelated + 19;
422
423 /**
424 * Inner types related problems
425 */
426 int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
427 int MissingEnclosingInstance = TypeRelated + 21;
428 int IncorrectEnclosingInstanceReference = TypeRelated + 22;
429 int IllegalEnclosingInstanceSpecification = TypeRelated + 23;
430 int CannotDefineStaticInitializerInLocalType = Internal + 24;
431 int OuterLocalMustBeFinal = Internal + 25;
432 int CannotDefineInterfaceInLocalType = Internal + 26;
433 int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27;
434 /** @since 2.1 */
435 int EnclosingInstanceInConstructorCall = Internal + 28;
436 int AnonymousClassCannotExtendFinalClass = TypeRelated + 29;
437 /** @since 3.1 */
438 int CannotDefineAnnotationInLocalType = Internal + 30;
439 /** @since 3.1 */
440 int CannotDefineEnumInLocalType = Internal + 31;
441 /** @since 3.1 */
442 int NonStaticContextForEnumMemberType = Internal + 32;
443 /** @since 3.3 */
444 int TypeHidingType = TypeRelated + 33;
445 /** @since 3.11 */
446 int NotAnnotationType = TypeRelated + 34;
447
448 // variables
449 int UndefinedName = Internal + FieldRelated + 50;
450 int UninitializedLocalVariable = Internal + 51;
451 int VariableTypeCannotBeVoid = Internal + 52;
452 /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
453 int VariableTypeCannotBeVoidArray = Internal + 53;
454 int CannotAllocateVoidArray = Internal + 54;
455 // local variables
456 int RedefinedLocal = Internal + 55;
457 int RedefinedArgument = Internal + 56;
458 // final local variables
459 int DuplicateFinalLocalInitialization = Internal + 57;
460 /** @since 2.1 */
461 int NonBlankFinalLocalAssignment = Internal + 58;
462 /** @since 3.2 */
463 int ParameterAssignment = Internal + 59;
464 int FinalOuterLocalAssignment = Internal + 60;
465 int LocalVariableIsNeverUsed = Internal + 61;
466 int ArgumentIsNeverUsed = Internal + 62;
467 int BytecodeExceeds64KLimit = Internal + 63;
468 int BytecodeExceeds64KLimitForClinit = Internal + 64;
469 int TooManyArgumentSlots = Internal + 65;
470 int TooManyLocalVariableSlots = Internal + 66;
471 /** @since 2.1 */
472 int TooManySyntheticArgumentSlots = Internal + 67;
473 /** @since 2.1 */
474 int TooManyArrayDimensions = Internal + 68;
475 /** @since 2.1 */
476 int BytecodeExceeds64KLimitForConstructor = Internal + 69;
477
478 // fields
479 int UndefinedField = FieldRelated + 70;
480 int NotVisibleField = FieldRelated + 71;
481 int AmbiguousField = FieldRelated + 72;
482 int UsingDeprecatedField = FieldRelated + 73;
483 int NonStaticFieldFromStaticInvocation = FieldRelated + 74;
484 int ReferenceToForwardField = FieldRelated + Internal + 75;
485 /** @since 2.1 */
486 int NonStaticAccessToStaticField = Internal + FieldRelated + 76;
487 /** @since 2.1 */
488 int UnusedPrivateField = Internal + FieldRelated + 77;
489 /** @since 3.0 */
490 int IndirectAccessToStaticField = Internal + FieldRelated + 78;
491 /** @since 3.0 */
492 int UnqualifiedFieldAccess = Internal + FieldRelated + 79;
493 int FinalFieldAssignment = FieldRelated + 80;
494 int UninitializedBlankFinalField = FieldRelated + 81;
495 int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
496 /** @since 3.6 */
497 int UnresolvedVariable = FieldRelated + 83;
498 /** @since 3.10 */
499 int NonStaticOrAlienTypeReceiver = MethodRelated + 84;
500
501 /** @since 3.11 */
502 int ExceptionParameterIsNeverUsed = Internal + 85;
503 /** @since 3.17 */
504 int BytecodeExceeds64KLimitForSwitchTable = Internal + 86;
505
506 // variable hiding
507 /** @since 3.0 */
508 int LocalVariableHidingLocalVariable = Internal + 90;
509 /** @since 3.0 */
510 int LocalVariableHidingField = Internal + FieldRelated + 91;
511 /** @since 3.0 */
512 int FieldHidingLocalVariable = Internal + FieldRelated + 92;
513 /** @since 3.0 */
514 int FieldHidingField = Internal + FieldRelated + 93;
515 /** @since 3.0 */
516 int ArgumentHidingLocalVariable = Internal + 94;
517 /** @since 3.0 */
518 int ArgumentHidingField = Internal + 95;
519 /** @since 3.1 */
520 int MissingSerialVersion = Internal + 96;
521 /** @since 3.10 */
522 int LambdaRedeclaresArgument = Internal + 97;
523 /** @since 3.10 */
524 int LambdaRedeclaresLocal = Internal + 98;
525 /** @since 3.10 */
526 int LambdaDescriptorMentionsUnmentionable = 99;
527
528 // methods
529 int UndefinedMethod = MethodRelated + 100;
530 int NotVisibleMethod = MethodRelated + 101;
531 int AmbiguousMethod = MethodRelated + 102;
532 int UsingDeprecatedMethod = MethodRelated + 103;
533 int DirectInvocationOfAbstractMethod = MethodRelated + 104;
534 int VoidMethodReturnsValue = MethodRelated + 105;
535 int MethodReturnsVoid = MethodRelated + 106;
536 int MethodRequiresBody = Internal + MethodRelated + 107;
537 int ShouldReturnValue = Internal + MethodRelated + 108;
538 int MethodButWithConstructorName = MethodRelated + 110;
539 int MissingReturnType = TypeRelated + 111;
540 int BodyForNativeMethod = Internal + MethodRelated + 112;
541 int BodyForAbstractMethod = Internal + MethodRelated + 113;
542 int NoMessageSendOnBaseType = MethodRelated + 114;
543 int ParameterMismatch = MethodRelated + 115;
544 int NoMessageSendOnArrayType = MethodRelated + 116;
545 /** @since 2.1 */
546 int NonStaticAccessToStaticMethod = Internal + MethodRelated + 117;
547 /** @since 2.1 */
548 int UnusedPrivateMethod = Internal + MethodRelated + 118;
549 /** @since 3.0 */
550 int IndirectAccessToStaticMethod = Internal + MethodRelated + 119;
551 /** @since 3.4 */
552 int MissingTypeInMethod = MethodRelated + 120;
553 /** @since 3.7 */
554 int MethodCanBeStatic = Internal + MethodRelated + 121;
555 /** @since 3.7 */
556 int MethodCanBePotentiallyStatic = Internal + MethodRelated + 122;
557 /** @since 3.10 */
558 int MethodReferenceSwingsBothWays = Internal + MethodRelated + 123;
559 /** @since 3.10 */
560 int StaticMethodShouldBeAccessedStatically = Internal + MethodRelated + 124;
561 /** @since 3.10 */
562 int InvalidArrayConstructorReference = Internal + MethodRelated + 125;
563 /** @since 3.10 */
564 int ConstructedArrayIncompatible = Internal + MethodRelated + 126;
565 /** @since 3.10 */
566 int DanglingReference = Internal + MethodRelated + 127;
567 /** @since 3.10 */
568 int IncompatibleMethodReference = Internal + MethodRelated + 128;
569
570 // constructors
571 /** @since 3.4 */
572 int MissingTypeInConstructor = ConstructorRelated + 129;
573 int UndefinedConstructor = ConstructorRelated + 130;
574 int NotVisibleConstructor = ConstructorRelated + 131;
575 int AmbiguousConstructor = ConstructorRelated + 132;
576 int UsingDeprecatedConstructor = ConstructorRelated + 133;
577 /** @since 2.1 */
578 int UnusedPrivateConstructor = Internal + MethodRelated + 134;
579 // explicit constructor calls
580 int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135;
581 int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136;
582 int RecursiveConstructorInvocation = ConstructorRelated + 137;
583 int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138;
584 /** @since 3.0 */
585 int InvalidExplicitConstructorCall = ConstructorRelated + Syntax + 139;
586 // implicit constructor calls
587 int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140;
588 int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141;
589 int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142;
590 int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143;
591 int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144;
592 int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145;
593 int UnhandledExceptionInDefaultConstructor = TypeRelated + 146;
594 int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147;
595
596 // expressions
597 /** @since 3.6 */
598 int UnusedObjectAllocation = Internal + 148;
599 /** @since 3.5 */
600 int DeadCode = Internal + 149;
601 int ArrayReferenceRequired = Internal + 150;
602 int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
603 // constant expressions
604 int StringConstantIsExceedingUtf8Limit = Internal + 152;
605 int NonConstantExpression = Internal + 153;
606 int NumericValueOutOfRange = Internal + 154;
607 // cast expressions
608 int IllegalCast = TypeRelated + 156;
609 // allocations
610 int InvalidClassInstantiation = TypeRelated + 157;
611 int CannotDefineDimensionExpressionsWithInit = Internal + 158;
612 int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159;
613 // operators
614 int InvalidOperator = Internal + 160;
615 // statements
616 int CodeCannotBeReached = Internal + 161;
617 int CannotReturnInInitializer = Internal + 162;
618 int InitializerMustCompleteNormally = Internal + 163;
619 // assert
620 int InvalidVoidExpression = Internal + 164;
621 // try
622 int MaskedCatch = TypeRelated + 165;
623 int DuplicateDefaultCase = Internal + 166;
624 int UnreachableCatch = TypeRelated + MethodRelated + 167;
625 int UnhandledException = TypeRelated + 168;
626 // switch
627 int IncorrectSwitchType = TypeRelated + 169;
628 int DuplicateCase = FieldRelated + 170;
629
630 // labelled
631 int DuplicateLabel = Internal + 171;
632 int InvalidBreak = Internal + 172;
633 int InvalidContinue = Internal + 173;
634 int UndefinedLabel = Internal + 174;
635 //synchronized
636 int InvalidTypeToSynchronized = Internal + 175;
637 int InvalidNullToSynchronized = Internal + 176;
638 // throw
639 int CannotThrowNull = Internal + 177;
640 // assignment
641 /** @since 2.1 */
642 int AssignmentHasNoEffect = Internal + 178;
643 /** @since 3.0 */
644 int PossibleAccidentalBooleanAssignment = Internal + 179;
645 /** @since 3.0 */
646 int SuperfluousSemicolon = Internal + 180;
647 /** @since 3.0 */
648 int UnnecessaryCast = Internal + TypeRelated + 181;
649 /** @deprecated - no longer generated, use {@link #UnnecessaryCast} instead
650 * @since 3.0 */
651 int UnnecessaryArgumentCast = Internal + TypeRelated + 182;
652 /** @since 3.0 */
653 int UnnecessaryInstanceof = Internal + TypeRelated + 183;
654 /** @since 3.0 */
655 int FinallyMustCompleteNormally = Internal + 184;
656 /** @since 3.0 */
657 int UnusedMethodDeclaredThrownException = Internal + 185;
658 /** @since 3.0 */
659 int UnusedConstructorDeclaredThrownException = Internal + 186;
660 /** @since 3.0 */
661 int InvalidCatchBlockSequence = Internal + TypeRelated + 187;
662 /** @since 3.0 */
663 int EmptyControlFlowStatement = Internal + TypeRelated + 188;
664 /** @since 3.0 */
665 int UnnecessaryElse = Internal + 189;
666
667 // inner emulation
668 int NeedToEmulateFieldReadAccess = FieldRelated + 190;
669 int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
670 int NeedToEmulateMethodAccess = MethodRelated + 192;
671 int NeedToEmulateConstructorAccess = MethodRelated + 193;
672
673 /** @since 3.2 */
674 int FallthroughCase = Internal + 194;
675
676 //inherited name hides enclosing name (sort of ambiguous)
677 int InheritedMethodHidesEnclosingName = MethodRelated + 195;
678 int InheritedFieldHidesEnclosingName = FieldRelated + 196;
679 int InheritedTypeHidesEnclosingName = TypeRelated + 197;
680
681 /** @since 3.1 */
682 int IllegalUsageOfQualifiedTypeReference = Internal + Syntax + 198;
683
684 // miscellaneous
685 /** @since 3.2 */
686 int UnusedLabel = Internal + 199;
687 int ThisInStaticContext = Internal + 200;
688 int StaticMethodRequested = Internal + MethodRelated + 201;
689 int IllegalDimension = Internal + 202;
690 /** @deprecated - problem is no longer generated */
691 int InvalidTypeExpression = Internal + 203;
692 int ParsingError = Syntax + Internal + 204;
693 int ParsingErrorNoSuggestion = Syntax + Internal + 205;
694 int InvalidUnaryExpression = Syntax + Internal + 206;
695
696 // syntax errors
697 int InterfaceCannotHaveConstructors = Syntax + Internal + 207;
698 int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208;
699 int ParsingErrorOnKeyword = Syntax + Internal + 209;
700 int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;
701
702 /** @since 3.5 */
703 int ComparingIdentical = Internal + 211;
704
705 /** @since 3.22
706 * @noreference preview feature error */
707 int UnsafeCast = TypeRelated + 212;
708
709 int UnmatchedBracket = Syntax + Internal + 220;
710 int NoFieldOnBaseType = FieldRelated + 221;
711 int InvalidExpressionAsStatement = Syntax + Internal + 222;
712 /** @since 2.1 */
713 int ExpressionShouldBeAVariable = Syntax + Internal + 223;
714 /** @since 2.1 */
715 int MissingSemiColon = Syntax + Internal + 224;
716 /** @since 2.1 */
717 int InvalidParenthesizedExpression = Syntax + Internal + 225;
718
719 /** @since 3.10 */
720 int NoSuperInInterfaceContext = Syntax + Internal + 226;
721
722 /** @since 3.0 */
723 int ParsingErrorInsertTokenBefore = Syntax + Internal + 230;
724 /** @since 3.0 */
725 int ParsingErrorInsertTokenAfter = Syntax + Internal + 231;
726 /** @since 3.0 */
727 int ParsingErrorDeleteToken = Syntax + Internal + 232;
728 /** @since 3.0 */
729 int ParsingErrorDeleteTokens = Syntax + Internal + 233;
730 /** @since 3.0 */
731 int ParsingErrorMergeTokens = Syntax + Internal + 234;
732 /** @since 3.0 */
733 int ParsingErrorInvalidToken = Syntax + Internal + 235;
734 /** @since 3.0 */
735 int ParsingErrorMisplacedConstruct = Syntax + Internal + 236;
736 /** @since 3.0 */
737 int ParsingErrorReplaceTokens = Syntax + Internal + 237;
738 /** @since 3.0 */
739 int ParsingErrorNoSuggestionForTokens = Syntax + Internal + 238;
740 /** @since 3.0 */
741 int ParsingErrorUnexpectedEOF = Syntax + Internal + 239;
742 /** @since 3.0 */
743 int ParsingErrorInsertToComplete = Syntax + Internal + 240;
744 /** @since 3.0 */
745 int ParsingErrorInsertToCompleteScope = Syntax + Internal + 241;
746 /** @since 3.0 */
747 int ParsingErrorInsertToCompletePhrase = Syntax + Internal + 242;
748
749 // scanner errors
750 int EndOfSource = Syntax + Internal + 250;
751 int InvalidHexa = Syntax + Internal + 251;
752 int InvalidOctal = Syntax + Internal + 252;
753 int InvalidCharacterConstant = Syntax + Internal + 253;
754 int InvalidEscape = Syntax + Internal + 254;
755 int InvalidInput = Syntax + Internal + 255;
756 int InvalidUnicodeEscape = Syntax + Internal + 256;
757 int InvalidFloat = Syntax + Internal + 257;
758 int NullSourceString = Syntax + Internal + 258;
759 int UnterminatedString = Syntax + Internal + 259;
760 int UnterminatedComment = Syntax + Internal + 260;
761 int NonExternalizedStringLiteral = Internal + 261;
762 /** @since 3.1 */
763 int InvalidDigit = Syntax + Internal + 262;
764 /** @since 3.1 */
765 int InvalidLowSurrogate = Syntax + Internal + 263;
766 /** @since 3.1 */
767 int InvalidHighSurrogate = Syntax + Internal + 264;
768 /** @since 3.2 */
769 int UnnecessaryNLSTag = Internal + 265;
770 /** @since 3.7.1 */
771 int InvalidBinary = Syntax + Internal + 266;
772 /** @since 3.7.1 */
773 int BinaryLiteralNotBelow17 = Syntax + Internal + 267;
774 /** @since 3.7.1 */
775 int IllegalUnderscorePosition = Syntax + Internal + 268;
776 /** @since 3.7.1 */
777 int UnderscoresInLiteralsNotBelow17 = Syntax + Internal + 269;
778 /** @since 3.7.1 */
779 int IllegalHexaLiteral = Syntax + Internal + 270;
780
781 /** @since 3.10 */
782 int MissingTypeInLambda = MethodRelated + 271;
783 /** @since 3.20
784 * @noreference preview related error */
785 int UnterminatedTextBlock = PreviewRelated + 272;
786 // type related problems
787 /** @since 3.1 */
788 int DiscouragedReference = TypeRelated + 280;
789
790 int InterfaceCannotHaveInitializers = TypeRelated + 300;
791 int DuplicateModifierForType = TypeRelated + 301;
792 int IllegalModifierForClass = TypeRelated + 302;
793 int IllegalModifierForInterface = TypeRelated + 303;
794 int IllegalModifierForMemberClass = TypeRelated + 304;
795 int IllegalModifierForMemberInterface = TypeRelated + 305;
796 int IllegalModifierForLocalClass = TypeRelated + 306;
797 /** @since 3.1 */
798 int ForbiddenReference = TypeRelated + 307;
799 int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308;
800 int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309;
801 int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310;
802 int IllegalStaticModifierForMemberType = TypeRelated + 311;
803 int SuperclassMustBeAClass = TypeRelated + 312;
804 int ClassExtendFinalClass = TypeRelated + 313;
805 int DuplicateSuperInterface = TypeRelated + 314;
806 int SuperInterfaceMustBeAnInterface = TypeRelated + 315;
807 int HierarchyCircularitySelfReference = TypeRelated + 316;
808 int HierarchyCircularity = TypeRelated + 317;
809 int HidingEnclosingType = TypeRelated + 318;
810 int DuplicateNestedType = TypeRelated + 319;
811 int CannotThrowType = TypeRelated + 320;
812 int PackageCollidesWithType = TypeRelated + 321;
813 int TypeCollidesWithPackage = TypeRelated + 322;
814 int DuplicateTypes = TypeRelated + 323;
815 int IsClassPathCorrect = TypeRelated + 324;
816 int PublicClassMustMatchFileName = TypeRelated + 325;
817 /** @deprecated - problem is no longer generated */
818 int MustSpecifyPackage = Internal + 326;
819 int HierarchyHasProblems = TypeRelated + 327;
820 int PackageIsNotExpectedPackage = Internal + 328;
821 /** @since 2.1 */
822 int ObjectCannotHaveSuperTypes = Internal + 329;
823 /** @since 3.1 */
824 int ObjectMustBeClass = Internal + 330;
825 /** @since 3.4 */
826 int RedundantSuperinterface = TypeRelated + 331;
827 /** @since 3.5 */
828 int ShouldImplementHashcode = TypeRelated + 332;
829 /** @since 3.5 */
830 int AbstractMethodsInConcreteClass = TypeRelated + 333;
831
832 /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
833 int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
834 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
835 int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
836 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
837 int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
838 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
839 int SuperclassInternalNameProvided = TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
840 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
841 int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
842
843 /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
844 int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
845 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
846 int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
847 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
848 int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
849 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
850 int InterfaceInternalNameProvided = TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
851 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
852 int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
853
854 // field related problems
855 int DuplicateField = FieldRelated + 340;
856 int DuplicateModifierForField = FieldRelated + 341;
857 int IllegalModifierForField = FieldRelated + 342;
858 int IllegalModifierForInterfaceField = FieldRelated + 343;
859 int IllegalVisibilityModifierCombinationForField = FieldRelated + 344;
860 int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345;
861 int UnexpectedStaticModifierForField = FieldRelated + 346;
862
863 /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
864 int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350
865 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
866 int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351
867 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
868 int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352
869 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
870 int FieldTypeInternalNameProvided = FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353
871 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
872 int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349 + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354
873
874 // method related problems
875 int DuplicateMethod = MethodRelated + 355;
876 int IllegalModifierForArgument = MethodRelated + 356;
877 int DuplicateModifierForMethod = MethodRelated + 357;
878 int IllegalModifierForMethod = MethodRelated + 358;
879 int IllegalModifierForInterfaceMethod = MethodRelated + 359;
880 int IllegalVisibilityModifierCombinationForMethod = MethodRelated + 360;
881 int UnexpectedStaticModifierForMethod = MethodRelated + 361;
882 int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
883 int AbstractMethodInAbstractClass = MethodRelated + 363;
884 int ArgumentTypeCannotBeVoid = MethodRelated + 364;
885 /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
886 int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
887 /** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
888 int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
889 int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
890 int DuplicateModifierForArgument = MethodRelated + 368;
891 /** @since 3.5 */
892 int IllegalModifierForConstructor = MethodRelated + 369;
893
894 /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
895 int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
896 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
897 int ArgumentTypeNotVisible = MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
898 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
899 int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
900 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
901 int ArgumentTypeInternalNameProvided = MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
902 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
903 int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
904
905 /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
906 int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
907 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
908 int ExceptionTypeNotVisible = MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
909 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
910 int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
911 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
912 int ExceptionTypeInternalNameProvided = MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
913 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
914 int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
915
916 /** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
917 int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
918 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
919 int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
920 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
921 int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
922 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
923 int ReturnTypeInternalNameProvided = MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
924 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
925 int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
926
927 // import related problems
928 int ConflictingImport = ImportRelated + 385;
929 int DuplicateImport = ImportRelated + 386;
930 int CannotImportPackage = ImportRelated + 387;
931 int UnusedImport = ImportRelated + 388;
932
933 int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
934 /** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
935 int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
936 /** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
937 int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
938 /** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
939 int ImportInternalNameProvided = ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
940 /** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
941 int ImportInheritedNameHidesEnclosingName = ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
942
943 /** @since 3.1 */
944 int InvalidTypeForStaticImport = ImportRelated + 391;
945
946 // local variable related problems
947 int DuplicateModifierForVariable = MethodRelated + 395;
948 int IllegalModifierForVariable = MethodRelated + 396;
949 /** @deprecated - problem is no longer generated, use {@link #RedundantNullCheckOnNonNullLocalVariable} instead */
950 int LocalVariableCannotBeNull = Internal + 397; // since 3.3: semantics are LocalVariableRedundantCheckOnNonNull
951 /** @deprecated - problem is no longer generated, use {@link #NullLocalVariableReference}, {@link #RedundantNullCheckOnNullLocalVariable} or {@link #RedundantLocalVariableNullAssignment} instead */
952 int LocalVariableCanOnlyBeNull = Internal + 398; // since 3.3: split with LocalVariableRedundantCheckOnNull depending on context
953 /** @deprecated - problem is no longer generated, use {@link #PotentialNullLocalVariableReference} instead */
954 int LocalVariableMayBeNull = Internal + 399;
955
956 // method verifier problems
957 int AbstractMethodMustBeImplemented = MethodRelated + 400;
958 int FinalMethodCannotBeOverridden = MethodRelated + 401;
959 int IncompatibleExceptionInThrowsClause = MethodRelated + 402;
960 int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403;
961 int IncompatibleReturnType = MethodRelated + 404;
962 int InheritedMethodReducesVisibility = MethodRelated + 405;
963 int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406;
964 int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407;
965 int StaticInheritedMethodConflicts = MethodRelated + 408;
966 int MethodReducesVisibility = MethodRelated + 409;
967 int OverridingNonVisibleMethod = MethodRelated + 410;
968 int AbstractMethodCannotBeOverridden = MethodRelated + 411;
969 int OverridingDeprecatedMethod = MethodRelated + 412;
970 /** @since 2.1 */
971 int IncompatibleReturnTypeForNonInheritedInterfaceMethod = MethodRelated + 413;
972 /** @since 2.1 */
973 int IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod = MethodRelated + 414;
974 /** @since 3.1 */
975 int IllegalVararg = MethodRelated + 415;
976 /** @since 3.3 */
977 int OverridingMethodWithoutSuperInvocation = MethodRelated + 416;
978 /** @since 3.5 */
979 int MissingSynchronizedModifierInInheritedMethod= MethodRelated + 417;
980 /** @since 3.5 */
981 int AbstractMethodMustBeImplementedOverConcreteMethod = MethodRelated + 418;
982 /** @since 3.5 */
983 int InheritedIncompatibleReturnType = MethodRelated + 419;
984
985 // code snippet support
986 int CodeSnippetMissingClass = Internal + 420;
987 int CodeSnippetMissingMethod = Internal + 421;
988 int CannotUseSuperInCodeSnippet = Internal + 422;
989
990 //constant pool
991 int TooManyConstantsInConstantPool = Internal + 430;
992 /** @since 2.1 */
993 int TooManyBytesForStringConstant = Internal + 431;
994
995 // static constraints
996 /** @since 2.1 */
997 int TooManyFields = Internal + 432;
998 /** @since 2.1 */
999 int TooManyMethods = Internal + 433;
1000 /** @since 3.7 */
1001 int TooManyParametersForSyntheticMethod = Internal + 434;
1002
1003 // 1.4 features
1004 // assertion warning
1005 int UseAssertAsAnIdentifier = Internal + 440;
1006
1007 // 1.5 features
1008 int UseEnumAsAnIdentifier = Internal + 441;
1009 /** @since 3.2 */
1010 int EnumConstantsCannotBeSurroundedByParenthesis = Syntax + Internal + 442;
1011
1012 /** @since 3.10 */
1013 int IllegalUseOfUnderscoreAsAnIdentifier = Syntax + Internal + 443;
1014 /** @since 3.10 */
1015 int UninternedIdentityComparison = Syntax + Internal + 444;
1016
1017 // detected task
1018 /** @since 2.1 */
1019 int Task = Internal + 450;
1020
1021 // local variables related problems, cont'd
1022 /** @since 3.3 */
1023 int NullLocalVariableReference = Internal + 451;
1024 /** @since 3.3 */
1025 int PotentialNullLocalVariableReference = Internal + 452;
1026 /** @since 3.3 */
1027 int RedundantNullCheckOnNullLocalVariable = Internal + 453;
1028 /** @since 3.3 */
1029 int NullLocalVariableComparisonYieldsFalse = Internal + 454;
1030 /** @since 3.3 */
1031 int RedundantLocalVariableNullAssignment = Internal + 455;
1032 /** @since 3.3 */
1033 int NullLocalVariableInstanceofYieldsFalse = Internal + 456;
1034 /** @since 3.3 */
1035 int RedundantNullCheckOnNonNullLocalVariable = Internal + 457;
1036 /** @since 3.3 */
1037 int NonNullLocalVariableComparisonYieldsFalse = Internal + 458;
1038 /** @since 3.9 */
1039 int PotentialNullUnboxing = Internal + 459;
1040 /** @since 3.9 */
1041 int NullUnboxing = Internal + 461;
1042
1043 // block
1044 /** @since 3.0 */
1045 int UndocumentedEmptyBlock = Internal + 460;
1046
1047 /*
1048 * Javadoc comments
1049 */
1050 /**
1051 * Problem signaled on an invalid URL reference.
1052 * Valid syntax example: @see "http://www.eclipse.org/"
1053 * @since 3.4
1054 */
1055 int JavadocInvalidSeeUrlReference = Javadoc + Internal + 462;
1056 /**
1057 * Problem warned on missing tag description.
1058 * @since 3.4
1059 */
1060 int JavadocMissingTagDescription = Javadoc + Internal + 463;
1061 /**
1062 * Problem warned on duplicated tag.
1063 * @since 3.3
1064 */
1065 int JavadocDuplicateTag = Javadoc + Internal + 464;
1066 /**
1067 * Problem signaled on an hidden reference due to a too low visibility level.
1068 * @since 3.3
1069 */
1070 int JavadocHiddenReference = Javadoc + Internal + 465;
1071 /**
1072 * Problem signaled on an invalid qualification for member type reference.
1073 * @since 3.3
1074 */
1075 int JavadocInvalidMemberTypeQualification = Javadoc + Internal + 466;
1076 /** @since 3.2 */
1077 int JavadocMissingIdentifier = Javadoc + Internal + 467;
1078 /** @since 3.2 */
1079 int JavadocNonStaticTypeFromStaticInvocation = Javadoc + Internal + 468;
1080 /** @since 3.1 */
1081 int JavadocInvalidParamTagTypeParameter = Javadoc + Internal + 469;
1082 /** @since 3.0 */
1083 int JavadocUnexpectedTag = Javadoc + Internal + 470;
1084 /** @since 3.0 */
1085 int JavadocMissingParamTag = Javadoc + Internal + 471;
1086 /** @since 3.0 */
1087 int JavadocMissingParamName = Javadoc + Internal + 472;
1088 /** @since 3.0 */
1089 int JavadocDuplicateParamName = Javadoc + Internal + 473;
1090 /** @since 3.0 */
1091 int JavadocInvalidParamName = Javadoc + Internal + 474;
1092 /** @since 3.0 */
1093 int JavadocMissingReturnTag = Javadoc + Internal + 475;
1094 /** @since 3.0 */
1095 int JavadocDuplicateReturnTag = Javadoc + Internal + 476;
1096 /** @since 3.0 */
1097 int JavadocMissingThrowsTag = Javadoc + Internal + 477;
1098 /** @since 3.0 */
1099 int JavadocMissingThrowsClassName = Javadoc + Internal + 478;
1100 /** @since 3.0 */
1101 int JavadocInvalidThrowsClass = Javadoc + Internal + 479;
1102 /** @since 3.0 */
1103 int JavadocDuplicateThrowsClassName = Javadoc + Internal + 480;
1104 /** @since 3.0 */
1105 int JavadocInvalidThrowsClassName = Javadoc + Internal + 481;
1106 /** @since 3.0 */
1107 int JavadocMissingSeeReference = Javadoc + Internal + 482;
1108 /** @since 3.0 */
1109 int JavadocInvalidSeeReference = Javadoc + Internal + 483;
1110 /**
1111 * Problem signaled on an invalid URL reference that does not conform to the href syntax.
1112 * Valid syntax example: @see <a href="http://www.eclipse.org/">Eclipse Home Page</a>
1113 * @since 3.0
1114 */
1115 int JavadocInvalidSeeHref = Javadoc + Internal + 484;
1116 /** @since 3.0 */
1117 int JavadocInvalidSeeArgs = Javadoc + Internal + 485;
1118 /** @since 3.0 */
1119 int JavadocMissing = Javadoc + Internal + 486;
1120 /** @since 3.0 */
1121 int JavadocInvalidTag = Javadoc + Internal + 487;
1122 /*
1123 * ID for field errors in Javadoc
1124 */
1125 /** @since 3.0 */
1126 int JavadocUndefinedField = Javadoc + Internal + 488;
1127 /** @since 3.0 */
1128 int JavadocNotVisibleField = Javadoc + Internal + 489;
1129 /** @since 3.0 */
1130 int JavadocAmbiguousField = Javadoc + Internal + 490;
1131 /** @since 3.0 */
1132 int JavadocUsingDeprecatedField = Javadoc + Internal + 491;
1133 /*
1134 * IDs for constructor errors in Javadoc
1135 */
1136 /** @since 3.0 */
1137 int JavadocUndefinedConstructor = Javadoc + Internal + 492;
1138 /** @since 3.0 */
1139 int JavadocNotVisibleConstructor = Javadoc + Internal + 493;
1140 /** @since 3.0 */
1141 int JavadocAmbiguousConstructor = Javadoc + Internal + 494;
1142 /** @since 3.0 */
1143 int JavadocUsingDeprecatedConstructor = Javadoc + Internal + 495;
1144 /*
1145 * IDs for method errors in Javadoc
1146 */
1147 /** @since 3.0 */
1148 int JavadocUndefinedMethod = Javadoc + Internal + 496;
1149 /** @since 3.0 */
1150 int JavadocNotVisibleMethod = Javadoc + Internal + 497;
1151 /** @since 3.0 */
1152 int JavadocAmbiguousMethod = Javadoc + Internal + 498;
1153 /** @since 3.0 */
1154 int JavadocUsingDeprecatedMethod = Javadoc + Internal + 499;
1155 /** @since 3.0 */
1156 int JavadocNoMessageSendOnBaseType = Javadoc + Internal + 500;
1157 /** @since 3.0 */
1158 int JavadocParameterMismatch = Javadoc + Internal + 501;
1159 /** @since 3.0 */
1160 int JavadocNoMessageSendOnArrayType = Javadoc + Internal + 502;
1161 /*
1162 * IDs for type errors in Javadoc
1163 */
1164 /** @since 3.0 */
1165 int JavadocUndefinedType = Javadoc + Internal + 503;
1166 /** @since 3.0 */
1167 int JavadocNotVisibleType = Javadoc + Internal + 504;
1168 /** @since 3.0 */
1169 int JavadocAmbiguousType = Javadoc + Internal + 505;
1170 /** @since 3.0 */
1171 int JavadocUsingDeprecatedType = Javadoc + Internal + 506;
1172 /** @since 3.0 */
1173 int JavadocInternalTypeNameProvided = Javadoc + Internal + 507;
1174 /** @since 3.0 */
1175 int JavadocInheritedMethodHidesEnclosingName = Javadoc + Internal + 508;
1176 /** @since 3.0 */
1177 int JavadocInheritedFieldHidesEnclosingName = Javadoc + Internal + 509;
1178 /** @since 3.0 */
1179 int JavadocInheritedNameHidesEnclosingTypeName = Javadoc + Internal + 510;
1180 /** @since 3.0 */
1181 int JavadocAmbiguousMethodReference = Javadoc + Internal + 511;
1182 /** @since 3.0 */
1183 int JavadocUnterminatedInlineTag = Javadoc + Internal + 512;
1184 /** @since 3.0 */
1185 int JavadocMalformedSeeReference = Javadoc + Internal + 513;
1186 /** @since 3.0 */
1187 int JavadocMessagePrefix = Internal + 514;
1188
1189 /** @since 3.1 */
1190 int JavadocMissingHashCharacter = Javadoc + Internal + 515;
1191 /** @since 3.1 */
1192 int JavadocEmptyReturnTag = Javadoc + Internal + 516;
1193 /** @since 3.1 */
1194 int JavadocInvalidValueReference = Javadoc + Internal + 517;
1195 /** @since 3.1 */
1196 int JavadocUnexpectedText = Javadoc + Internal + 518;
1197 /** @since 3.1 */
1198 int JavadocInvalidParamTagName = Javadoc + Internal + 519;
1199
1200 // see also JavadocNotAccessibleType below
1201
1202 /*
1203 * IDs for module errors in Javadoc
1204 */
1205 /** @since 3.20 */
1206 int JavadocMissingUsesTag = Javadoc + Internal + 1800;
1207 /** @since 3.20 */
1208 int JavadocDuplicateUsesTag = Javadoc + Internal + 1801;
1209 /** @since 3.20 */
1210 int JavadocMissingUsesClassName = Javadoc + Internal + 1802;
1211 /** @since 3.20 */
1212 int JavadocInvalidUsesClassName = Javadoc + Internal + 1803;
1213 /** @since 3.20 */
1214 int JavadocInvalidUsesClass = Javadoc + Internal + 1804;
1215 /** @since 3.20 */
1216 int JavadocMissingProvidesTag = Javadoc + Internal + 1805;
1217 /** @since 3.20 */
1218 int JavadocDuplicateProvidesTag = Javadoc + Internal + 1806;
1219 /** @since 3.20 */
1220 int JavadocMissingProvidesClassName = Javadoc + Internal + 1807;
1221 /** @since 3.20 */
1222 int JavadocInvalidProvidesClassName = Javadoc + Internal + 1808;
1223 /** @since 3.20 */
1224 int JavadocInvalidProvidesClass = Javadoc + Internal + 1809;
1225
1226 /**
1227 * Generics
1228 */
1229 /** @since 3.1 */
1230 int DuplicateTypeVariable = Internal + 520;
1231 /** @since 3.1 */
1232 int IllegalTypeVariableSuperReference = Internal + 521;
1233 /** @since 3.1 */
1234 int NonStaticTypeFromStaticInvocation = Internal + 522;
1235 /** @since 3.1 */
1236 int ObjectCannotBeGeneric = Internal + 523;
1237 /** @since 3.1 */
1238 int NonGenericType = TypeRelated + 524;
1239 /** @since 3.1 */
1240 int IncorrectArityForParameterizedType = TypeRelated + 525;
1241 /** @since 3.1 */
1242 int TypeArgumentMismatch = TypeRelated + 526;
1243 /** @since 3.1 */
1244 int DuplicateMethodErasure = TypeRelated + 527;
1245 /** @since 3.1 */
1246 int ReferenceToForwardTypeVariable = TypeRelated + 528;
1247 /** @since 3.1 */
1248 int BoundMustBeAnInterface = TypeRelated + 529;
1249 /** @since 3.1 */
1250 int UnsafeRawConstructorInvocation = TypeRelated + 530;
1251 /** @since 3.1 */
1252 int UnsafeRawMethodInvocation = TypeRelated + 531;
1253 /** @since 3.1 */
1254 int UnsafeTypeConversion = TypeRelated + 532;
1255 /** @since 3.1 */
1256 int InvalidTypeVariableExceptionType = TypeRelated + 533;
1257 /** @since 3.1 */
1258 int InvalidParameterizedExceptionType = TypeRelated + 534;
1259 /** @since 3.1 */
1260 int IllegalGenericArray = TypeRelated + 535;
1261 /** @since 3.1 */
1262 int UnsafeRawFieldAssignment = TypeRelated + 536;
1263 /** @since 3.1 */
1264 int FinalBoundForTypeVariable = TypeRelated + 537;
1265 /** @since 3.1 */
1266 int UndefinedTypeVariable = Internal + 538;
1267 /** @since 3.1 */
1268 int SuperInterfacesCollide = TypeRelated + 539;
1269 /** @since 3.1 */
1270 int WildcardConstructorInvocation = TypeRelated + 540;
1271 /** @since 3.1 */
1272 int WildcardMethodInvocation = TypeRelated + 541;
1273 /** @since 3.1 */
1274 int WildcardFieldAssignment = TypeRelated + 542;
1275 /** @since 3.1 */
1276 int GenericMethodTypeArgumentMismatch = TypeRelated + 543;
1277 /** @since 3.1 */
1278 int GenericConstructorTypeArgumentMismatch = TypeRelated + 544;
1279 /** @since 3.1 */
1280 int UnsafeGenericCast = TypeRelated + 545;
1281 /** @since 3.1 */
1282 int IllegalInstanceofParameterizedType = Internal + 546;
1283 /** @since 3.1 */
1284 int IllegalInstanceofTypeParameter = Internal + 547;
1285 /** @since 3.1 */
1286 int NonGenericMethod = TypeRelated + 548;
1287 /** @since 3.1 */
1288 int IncorrectArityForParameterizedMethod = TypeRelated + 549;
1289 /** @since 3.1 */
1290 int ParameterizedMethodArgumentTypeMismatch = TypeRelated + 550;
1291 /** @since 3.1 */
1292 int NonGenericConstructor = TypeRelated + 551;
1293 /** @since 3.1 */
1294 int IncorrectArityForParameterizedConstructor = TypeRelated + 552;
1295 /** @since 3.1 */
1296 int ParameterizedConstructorArgumentTypeMismatch = TypeRelated + 553;
1297 /** @since 3.1 */
1298 int TypeArgumentsForRawGenericMethod = TypeRelated + 554;
1299 /** @since 3.1 */
1300 int TypeArgumentsForRawGenericConstructor = TypeRelated + 555;
1301 /** @since 3.1 */
1302 int SuperTypeUsingWildcard = TypeRelated + 556;
1303 /** @since 3.1 */
1304 int GenericTypeCannotExtendThrowable = TypeRelated + 557;
1305 /** @since 3.1 */
1306 int IllegalClassLiteralForTypeVariable = TypeRelated + 558;
1307 /** @since 3.1 */
1308 int UnsafeReturnTypeOverride = MethodRelated + 559;
1309 /** @since 3.1 */
1310 int MethodNameClash = MethodRelated + 560;
1311 /** @since 3.1 */
1312 int RawMemberTypeCannotBeParameterized = TypeRelated + 561;
1313 /** @since 3.1 */
1314 int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;
1315 /** @since 3.1 */
1316 int StaticMemberOfParameterizedType = TypeRelated + 563;
1317 /** @since 3.1 */
1318 int BoundHasConflictingArguments = TypeRelated + 564;
1319 /** @since 3.1 */
1320 int DuplicateParameterizedMethods = MethodRelated + 565;
1321 /** @since 3.1 */
1322 int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;
1323 /** @since 3.1 */
1324 int DuplicateBounds = TypeRelated + 567;
1325 /** @since 3.1 */
1326 int BoundCannotBeArray = TypeRelated + 568;
1327 /** @since 3.1 */
1328 int UnsafeRawGenericConstructorInvocation = TypeRelated + 569;
1329 /** @since 3.1 */
1330 int UnsafeRawGenericMethodInvocation = TypeRelated + 570;
1331 /** @since 3.1 */
1332 int TypeParameterHidingType = TypeRelated + 571;
1333 /** @since 3.2 */
1334 int RawTypeReference = TypeRelated + 572;
1335 /** @since 3.2 */
1336 int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;
1337 /** @since 3.2 */
1338 int UnsafeGenericArrayForVarargs = MethodRelated + 574;
1339 /** @since 3.2 */
1340 int IllegalAccessFromTypeVariable = TypeRelated + 575;
1341 /** @since 3.3 */
1342 int TypeHidingTypeParameterFromType = TypeRelated + 576;
1343 /** @since 3.3 */
1344 int TypeHidingTypeParameterFromMethod = TypeRelated + 577;
1345 /** @since 3.3 */
1346 int InvalidUsageOfWildcard = Syntax + Internal + 578;
1347 /** @since 3.4 */
1348 int UnusedTypeArgumentsForMethodInvocation = MethodRelated + 579;
1349
1350 /**
1351 * Foreach
1352 */
1353 /** @since 3.1 */
1354 int IncompatibleTypesInForeach = TypeRelated + 580;
1355 /** @since 3.1 */
1356 int InvalidTypeForCollection = Internal + 581;
1357 /** @since 3.6*/
1358 int InvalidTypeForCollectionTarget14 = Internal + 582;
1359
1360 /** @since 3.7.1 */
1361 int DuplicateInheritedMethods = MethodRelated + 583;
1362 /** @since 3.8 */
1363 int MethodNameClashHidden = MethodRelated + 584;
1364
1365 /** @since 3.9 */
1366 int UnsafeElementTypeConversion = TypeRelated + 585;
1367 /** @since 3.11 */
1368 int InvalidTypeArguments = MethodRelated + TypeRelated + 586;
1369
1370 /**
1371 * 1.5 Syntax errors (when source level < 1.5)
1372 */
1373 /** @since 3.1 */
1374 int InvalidUsageOfTypeParameters = Syntax + Internal + 590;
1375 /** @since 3.1 */
1376 int InvalidUsageOfStaticImports = Syntax + Internal + 591;
1377 /** @since 3.1 */
1378 int InvalidUsageOfForeachStatements = Syntax + Internal + 592;
1379 /** @since 3.1 */
1380 int InvalidUsageOfTypeArguments = Syntax + Internal + 593;
1381 /** @since 3.1 */
1382 int InvalidUsageOfEnumDeclarations = Syntax + Internal + 594;
1383 /** @since 3.1 */
1384 int InvalidUsageOfVarargs = Syntax + Internal + 595;
1385 /** @since 3.1 */
1386 int InvalidUsageOfAnnotations = Syntax + Internal + 596;
1387 /** @since 3.1 */
1388 int InvalidUsageOfAnnotationDeclarations = Syntax + Internal + 597;
1389 /** @since 3.4 */
1390 int InvalidUsageOfTypeParametersForAnnotationDeclaration = Syntax + Internal + 598;
1391 /** @since 3.4 */
1392 int InvalidUsageOfTypeParametersForEnumDeclaration = Syntax + Internal + 599;
1393 /**
1394 * Annotation
1395 */
1396 /** @since 3.1 */
1397 int IllegalModifierForAnnotationMethod = MethodRelated + 600;
1398 /** @since 3.1 */
1399 int IllegalExtendedDimensions = MethodRelated + 601;
1400 /** @since 3.1 */
1401 int InvalidFileNameForPackageAnnotations = Syntax + Internal + 602;
1402 /** @since 3.1 */
1403 int IllegalModifierForAnnotationType = TypeRelated + 603;
1404 /** @since 3.1 */
1405 int IllegalModifierForAnnotationMemberType = TypeRelated + 604;
1406 /** @since 3.1 */
1407 int InvalidAnnotationMemberType = TypeRelated + 605;
1408 /** @since 3.1 */
1409 int AnnotationCircularitySelfReference = TypeRelated + 606;
1410 /** @since 3.1 */
1411 int AnnotationCircularity = TypeRelated + 607;
1412 /** @since 3.1 */
1413 int DuplicateAnnotation = TypeRelated + 608;
1414 /** @since 3.1 */
1415 int MissingValueForAnnotationMember = TypeRelated + 609;
1416 /** @since 3.1 */
1417 int DuplicateAnnotationMember = Internal + 610;
1418 /** @since 3.1 */
1419 int UndefinedAnnotationMember = MethodRelated + 611;
1420 /** @since 3.1 */
1421 int AnnotationValueMustBeClassLiteral = Internal + 612;
1422 /** @since 3.1 */
1423 int AnnotationValueMustBeConstant = Internal + 613;
1424 /** @deprecated - problem is no longer generated (code is legite)
1425 * @since 3.1 */
1426 int AnnotationFieldNeedConstantInitialization = Internal + 614;
1427 /** @since 3.1 */
1428 int IllegalModifierForAnnotationField = Internal + 615;
1429 /** @since 3.1 */
1430 int AnnotationCannotOverrideMethod = MethodRelated + 616;
1431 /** @since 3.1 */
1432 int AnnotationMembersCannotHaveParameters = Syntax + Internal + 617;
1433 /** @since 3.1 */
1434 int AnnotationMembersCannotHaveTypeParameters = Syntax + Internal + 618;
1435 /** @since 3.1 */
1436 int AnnotationTypeDeclarationCannotHaveSuperclass = Syntax + Internal + 619;
1437 /** @since 3.1 */
1438 int AnnotationTypeDeclarationCannotHaveSuperinterfaces = Syntax + Internal + 620;
1439 /** @since 3.1 */
1440 int DuplicateTargetInTargetAnnotation = Internal + 621;
1441 /** @since 3.1 */
1442 int DisallowedTargetForAnnotation = TypeRelated + 622;
1443 /** @since 3.1 */
1444 int MethodMustOverride = MethodRelated + 623;
1445 /** @since 3.1 */
1446 int AnnotationTypeDeclarationCannotHaveConstructor = Syntax + Internal + 624;
1447 /** @since 3.1 */
1448 int AnnotationValueMustBeAnnotation = Internal + 625;
1449 /** @since 3.1 */
1450 int AnnotationTypeUsedAsSuperInterface = TypeRelated + 626;
1451 /** @since 3.1 */
1452 int MissingOverrideAnnotation = MethodRelated + 627;
1453 /** @since 3.1 */
1454 int FieldMissingDeprecatedAnnotation = Internal + 628;
1455 /** @since 3.1 */
1456 int MethodMissingDeprecatedAnnotation = Internal + 629;
1457 /** @since 3.1 */
1458 int TypeMissingDeprecatedAnnotation = Internal + 630;
1459 /** @since 3.1 */
1460 int UnhandledWarningToken = Internal + 631;
1461 /** @since 3.2 */
1462 int AnnotationValueMustBeArrayInitializer = Internal + 632;
1463 /** @since 3.3 */
1464 int AnnotationValueMustBeAnEnumConstant = Internal + 633;
1465 /** @since 3.3 */
1466 int MethodMustOverrideOrImplement = MethodRelated + 634;
1467 /** @since 3.4 */
1468 int UnusedWarningToken = Internal + 635;
1469 /** @since 3.6 */
1470 int MissingOverrideAnnotationForInterfaceMethodImplementation = MethodRelated + 636;
1471 /** @since 3.10 */
1472 int InvalidUsageOfTypeAnnotations = Syntax + Internal + 637;
1473 /** @since 3.10 */
1474 int DisallowedExplicitThisParameter = Syntax + Internal + 638;
1475 /** @since 3.10 */
1476 int MisplacedTypeAnnotations = Syntax + Internal + 639;
1477 /** @since 3.10 */
1478 int IllegalTypeAnnotationsInStaticMemberAccess = Internal + Syntax + 640;
1479 /** @since 3.10 */
1480 int IllegalUsageOfTypeAnnotations = Internal + Syntax + 641;
1481 /** @since 3.10 */
1482 int IllegalDeclarationOfThisParameter = Internal + Syntax + 642;
1483 /** @since 3.10 */
1484 int ExplicitThisParameterNotBelow18 = Internal + Syntax + 643;
1485 /** @since 3.10 */
1486 int DefaultMethodNotBelow18 = Internal + Syntax + 644;
1487 /** @since 3.10 */
1488 int LambdaExpressionNotBelow18 = Internal + Syntax + 645;
1489 /** @since 3.10 */
1490 int MethodReferenceNotBelow18 = Internal + Syntax + 646;
1491 /** @since 3.10 */
1492 int ConstructorReferenceNotBelow18 = Internal + Syntax + 647;
1493 /** @since 3.10 */
1494 int ExplicitThisParameterNotInLambda = Internal + Syntax + 648;
1495 /**
1496 * @since 3.10
1497 * @deprecated Per https://bugs.openjdk.java.net/browse/JDK-8231435 this problem is no longer raised
1498 */
1499 @Deprecated
1500 int ExplicitAnnotationTargetRequired = TypeRelated + 649;
1501 /** @since 3.10 */
1502 int IllegalTypeForExplicitThis = Internal + Syntax + 650;
1503 /** @since 3.10 */
1504 int IllegalQualifierForExplicitThis = Internal + Syntax + 651;
1505 /** @since 3.10 */
1506 int IllegalQualifierForExplicitThis2 = Internal + Syntax + 652;
1507 /** @since 3.10 */
1508 int TargetTypeNotAFunctionalInterface = Internal + TypeRelated + 653;
1509 /** @since 3.10 */
1510 int IllegalVarargInLambda = Internal + TypeRelated + 654;
1511 /** @since 3.10 */
1512 int illFormedParameterizationOfFunctionalInterface = Internal + TypeRelated + 655;
1513 /** @since 3.10 */
1514 int lambdaSignatureMismatched = Internal + TypeRelated + 656;
1515 /** @since 3.10 */
1516 int lambdaParameterTypeMismatched = Internal + TypeRelated + 657;
1517 /** @since 3.10 */
1518 int IncompatibleLambdaParameterType = Internal + TypeRelated + 658;
1519 /** @since 3.10 */
1520 int NoGenericLambda = Internal + TypeRelated + 659;
1521 /**
1522 * More problems in generics
1523 */
1524 /** @since 3.4 */
1525 int UnusedTypeArgumentsForConstructorInvocation = MethodRelated + 660;
1526 /** @since 3.9 */
1527 int UnusedTypeParameter = TypeRelated + 661;
1528 /** @since 3.9 */
1529 int IllegalArrayOfUnionType = TypeRelated + 662;
1530 /** @since 3.10 */
1531 int OuterLocalMustBeEffectivelyFinal = Internal + 663;
1532 /** @since 3.10 */
1533 int InterfaceNotFunctionalInterface = Internal + TypeRelated + 664;
1534 /** @since 3.10 */
1535 int ConstructionTypeMismatch = Internal + TypeRelated + 665;
1536 /** @since 3.10 */
1537 int ToleratedMisplacedTypeAnnotations = Syntax + Internal + 666;
1538 /** @since 3.13*/
1539 int InterfaceSuperInvocationNotBelow18 = Internal + Syntax + 667;
1540 /** @since 3.13*/
1541 int InterfaceStaticMethodInvocationNotBelow18 = Internal + Syntax + 668;
1542 /** @since 3.14 */
1543 int FieldMustBeFinal = Internal + 669;
1544
1545
1546 /**
1547 * Null analysis for other kinds of expressions, syntactically nonnull
1548 */
1549 /** @since 3.9 */
1550 int NonNullExpressionComparisonYieldsFalse = Internal + 670;
1551 /** @since 3.9 */
1552 int RedundantNullCheckOnNonNullExpression = Internal + 671;
1553 /** @since 3.9 */
1554 int NullExpressionReference = Internal + 672;
1555 /** @since 3.9 */
1556 int PotentialNullExpressionReference = Internal + 673;
1557
1558 /**
1559 * Corrupted binaries
1560 */
1561 /** @since 3.1 */
1562 int CorruptedSignature = Internal + 700;
1563 /**
1564 * Corrupted source
1565 */
1566 /** @since 3.2 */
1567 int InvalidEncoding = Internal + 701;
1568 /** @since 3.2 */
1569 int CannotReadSource = Internal + 702;
1570
1571 /**
1572 * Autoboxing
1573 */
1574 /** @since 3.1 */
1575 int BoxingConversion = Internal + 720;
1576 /** @since 3.1 */
1577 int UnboxingConversion = Internal + 721;
1578
1579 /**
1580 * Enum
1581 */
1582 /** @since 3.1 */
1583 int IllegalModifierForEnum = TypeRelated + 750;
1584 /** @since 3.1 */
1585 int IllegalModifierForEnumConstant = FieldRelated + 751;
1586 /** @deprecated - problem could not be reported, enums cannot be local takes precedence
1587 * @since 3.1 */
1588 int IllegalModifierForLocalEnum = TypeRelated + 752;
1589 /** @since 3.1 */
1590 int IllegalModifierForMemberEnum = TypeRelated + 753;
1591 /** @since 3.1 */
1592 int CannotDeclareEnumSpecialMethod = MethodRelated + 754;
1593 /** @since 3.1 */
1594 int IllegalQualifiedEnumConstantLabel = FieldRelated + 755;
1595 /** @since 3.1 */
1596 int CannotExtendEnum = TypeRelated + 756;
1597 /** @since 3.1 */
1598 int CannotInvokeSuperConstructorInEnum = MethodRelated + 757;
1599 /** @since 3.1 */
1600 int EnumAbstractMethodMustBeImplemented = MethodRelated + 758;
1601 /** @since 3.1 */
1602 int EnumSwitchCannotTargetField = FieldRelated + 759;
1603 /** @since 3.1 */
1604 int IllegalModifierForEnumConstructor = MethodRelated + 760;
1605 /** @since 3.1 */
1606 int MissingEnumConstantCase = FieldRelated + 761;
1607 /** @since 3.2 */ // TODO need to fix 3.1.1 contribution (inline this constant on client side)
1608 int EnumStaticFieldInInInitializerContext = FieldRelated + 762;
1609 /** @since 3.4 */
1610 int EnumConstantMustImplementAbstractMethod = MethodRelated + 763;
1611 /** @since 3.5 */
1612 int EnumConstantCannotDefineAbstractMethod = MethodRelated + 764;
1613 /** @since 3.5 */
1614 int AbstractMethodInEnum = MethodRelated + 765;
1615 /** @since 3.8 */
1616 int MissingEnumDefaultCase = Internal + 766;
1617 /** @since 3.8 */
1618 int MissingDefaultCase = Internal + 767;
1619 /** @since 3.8 */
1620 int MissingEnumConstantCaseDespiteDefault = FieldRelated + 768;
1621 /** @since 3.8 */
1622 int UninitializedLocalVariableHintMissingDefault = Internal + 769;
1623 /** @since 3.8 */
1624 int UninitializedBlankFinalFieldHintMissingDefault = FieldRelated + 770;
1625 /** @since 3.8 */
1626 int ShouldReturnValueHintMissingDefault = MethodRelated + 771;
1627
1628 /**
1629 * Var args
1630 */
1631 /** @since 3.1 */
1632 int IllegalExtendedDimensionsForVarArgs = Syntax + Internal + 800;
1633 /** @since 3.1 */
1634 int MethodVarargsArgumentNeedCast = MethodRelated + 801;
1635 /** @since 3.1 */
1636 int ConstructorVarargsArgumentNeedCast = ConstructorRelated + 802;
1637 /** @since 3.1 */
1638 int VarargsConflict = MethodRelated + 803;
1639 /** @since 3.7.1 */
1640 int SafeVarargsOnFixedArityMethod = MethodRelated + 804;
1641 /** @since 3.7.1 */
1642 int SafeVarargsOnNonFinalInstanceMethod = MethodRelated + 805;
1643 /** @since 3.7.1 */
1644 int PotentialHeapPollutionFromVararg = MethodRelated + 806;
1645 /** @since 3.8 */
1646 int VarargsElementTypeNotVisible = MethodRelated + 807;
1647 /** @since 3.8 */
1648 int VarargsElementTypeNotVisibleForConstructor = ConstructorRelated + 808;
1649 /** @since 3.10 */
1650 int ApplicableMethodOverriddenByInapplicable = MethodRelated + 809;
1651
1652 /**
1653 * Javadoc Generic
1654 */
1655 /** @since 3.1 */
1656 int JavadocGenericMethodTypeArgumentMismatch = Javadoc + Internal + 850;
1657 /** @since 3.1 */
1658 int JavadocNonGenericMethod = Javadoc + Internal + 851;
1659 /** @since 3.1 */
1660 int JavadocIncorrectArityForParameterizedMethod = Javadoc + Internal + 852;
1661 /** @since 3.1 */
1662 int JavadocParameterizedMethodArgumentTypeMismatch = Javadoc + Internal + 853;
1663 /** @since 3.1 */
1664 int JavadocTypeArgumentsForRawGenericMethod = Javadoc + Internal + 854;
1665 /** @since 3.1 */
1666 int JavadocGenericConstructorTypeArgumentMismatch = Javadoc + Internal + 855;
1667 /** @since 3.1 */
1668 int JavadocNonGenericConstructor = Javadoc + Internal + 856;
1669 /** @since 3.1 */
1670 int JavadocIncorrectArityForParameterizedConstructor = Javadoc + Internal + 857;
1671 /** @since 3.1 */
1672 int JavadocParameterizedConstructorArgumentTypeMismatch = Javadoc + Internal + 858;
1673 /** @since 3.1 */
1674 int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;
1675
1676 /**
1677 * Java 7 errors
1678 */
1679 /** @since 3.7.1 */
1680 int AssignmentToMultiCatchParameter = Internal + 870;
1681 /** @since 3.7.1 */
1682 int ResourceHasToImplementAutoCloseable = TypeRelated + 871;
1683 /** @since 3.7.1 */
1684 int AssignmentToResource = Internal + 872;
1685 /** @since 3.7.1 */
1686 int InvalidUnionTypeReferenceSequence = Internal + TypeRelated + 873;
1687 /** @since 3.7.1 */
1688 int AutoManagedResourceNotBelow17 = Syntax + Internal + 874;
1689 /** @since 3.7.1 */
1690 int MultiCatchNotBelow17 = Syntax + Internal + 875;
1691 /** @since 3.7.1 */
1692 int PolymorphicMethodNotBelow17 = MethodRelated + 876;
1693 /** @since 3.7.1 */
1694 int IncorrectSwitchType17 = TypeRelated + 877;
1695 /** @since 3.7.1 */
1696 int CannotInferElidedTypes = TypeRelated + 878;
1697 /** @since 3.7.1 */
1698 int CannotUseDiamondWithExplicitTypeArguments = TypeRelated + 879;
1699 /** @since 3.7.1 */
1700 int CannotUseDiamondWithAnonymousClasses = TypeRelated + 880;
1701 /** @since 3.7.1 */
1702 int SwitchOnStringsNotBelow17 = TypeRelated + 881; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=348492
1703 /** @since 3.7.1 */
1704 int UnhandledExceptionOnAutoClose = TypeRelated + 882;
1705 /** @since 3.7.1 */
1706 int DiamondNotBelow17 = TypeRelated + 883;
1707 /** @since 3.7.1 */
1708 int RedundantSpecificationOfTypeArguments = TypeRelated + 884;
1709 /** @since 3.8 */
1710 int PotentiallyUnclosedCloseable = Internal + 885;
1711 /** @since 3.8 */
1712 int PotentiallyUnclosedCloseableAtExit = Internal + 886;
1713 /** @since 3.8 */
1714 int UnclosedCloseable = Internal + 887;
1715 /** @since 3.8 */
1716 int UnclosedCloseableAtExit = Internal + 888;
1717 /** @since 3.8 */
1718 int ExplicitlyClosedAutoCloseable = Internal + 889;
1719 /** @since 3.8 */
1720 int SwitchOnEnumNotBelow15 = TypeRelated + 890; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=360317
1721 /** @since 3.10 */
1722 int IntersectionCastNotBelow18 = TypeRelated + 891;
1723 /** @since 3.10 */
1724 int IllegalBasetypeInIntersectionCast = TypeRelated + 892;
1725 /** @since 3.10 */
1726 int IllegalArrayTypeInIntersectionCast = TypeRelated + 893;
1727 /** @since 3.10 */
1728 int DuplicateBoundInIntersectionCast = TypeRelated + 894;
1729 /** @deprecated This problem is no longer reported; number Of functional interface is not an issue, number of abstract methods is.
1730 * @since 3.10 */
1731 int MultipleFunctionalInterfaces = TypeRelated + 895;
1732 /** @since 3.10 */
1733 int StaticInterfaceMethodNotBelow18 = Internal + Syntax + 896;
1734 /** @since 3.10 */
1735 int DuplicateAnnotationNotMarkedRepeatable = TypeRelated + 897;
1736 /** @since 3.10 */
1737 int DisallowedTargetForContainerAnnotationType = TypeRelated + 898;
1738 /** @since 3.10 */
1739 int RepeatedAnnotationWithContainerAnnotation = TypeRelated + 899;
1740
1741 /** @since 3.14 */
1742 int AutoManagedVariableResourceNotBelow9 = Syntax + Internal + 1351;
1743 /**
1744 * External problems -- These are problems defined by other plugins
1745 */
1746
1747 /** @since 3.2 */
1748 int ExternalProblemNotFixable = 900;
1749
1750 // indicates an externally defined problem that has a quick-assist processor
1751 // associated with it
1752 /** @since 3.2 */
1753 int ExternalProblemFixable = 901;
1754
1755 /** @since 3.10 */
1756 int ContainerAnnotationTypeHasWrongValueType = TypeRelated + 902;
1757 /** @since 3.10 */
1758 int ContainerAnnotationTypeMustHaveValue = TypeRelated + 903;
1759 /** @since 3.10 */
1760 int ContainerAnnotationTypeHasNonDefaultMembers = TypeRelated + 904;
1761 /** @since 3.10 */
1762 int ContainerAnnotationTypeHasShorterRetention = TypeRelated + 905;
1763 /** @since 3.10 */
1764 int RepeatableAnnotationTypeTargetMismatch = TypeRelated + 906;
1765 /** @since 3.10 */
1766 int RepeatableAnnotationTypeIsDocumented = TypeRelated + 907;
1767 /** @since 3.10 */
1768 int RepeatableAnnotationTypeIsInherited = TypeRelated + 908;
1769 /** @since 3.10 */
1770 int RepeatableAnnotationWithRepeatingContainerAnnotation = TypeRelated + 909;
1771
1772 /**
1773 * Errors/warnings from annotation based null analysis
1774 */
1775 /** @since 3.8 */
1776 int RequiredNonNullButProvidedNull = TypeRelated + 910;
1777 /** @since 3.8 */
1778 int RequiredNonNullButProvidedPotentialNull = TypeRelated + 911;
1779 /** @since 3.8 */
1780 int RequiredNonNullButProvidedUnknown = TypeRelated + 912;
1781 /** @since 3.8 */
1782 int MissingNonNullByDefaultAnnotationOnPackage = Internal + 913; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=372012
1783 /** @since 3.8 */
1784 int IllegalReturnNullityRedefinition = MethodRelated + 914;
1785 /** @since 3.8 */
1786 int IllegalRedefinitionToNonNullParameter = MethodRelated + 915;
1787 /** @since 3.8 */
1788 int IllegalDefinitionToNonNullParameter = MethodRelated + 916;
1789 /** @since 3.8 */
1790 int ParameterLackingNonNullAnnotation = MethodRelated + 917;
1791 /** @since 3.8 */
1792 int ParameterLackingNullableAnnotation = MethodRelated + 918;
1793 /** @since 3.8 */
1794 int PotentialNullMessageSendReference = Internal + 919;
1795 /** @since 3.8 */
1796 int RedundantNullCheckOnNonNullMessageSend = Internal + 920;
1797 /** @since 3.8 */
1798 int CannotImplementIncompatibleNullness = Internal + 921;
1799 /** @since 3.8 */
1800 int RedundantNullAnnotation = MethodRelated + 922;
1801 /** @since 3.8 */
1802 int IllegalAnnotationForBaseType = TypeRelated + 923;
1803 /** @since 3.9 */
1804 int NullableFieldReference = FieldRelated + 924;
1805 /** @since 3.8 */
1806 int RedundantNullDefaultAnnotation = Internal + 925; // shouldn't actually occur any more after bug 366063
1807 /** @since 3.8 */
1808 int RedundantNullDefaultAnnotationPackage = Internal + 926;
1809 /** @since 3.8 */
1810 int RedundantNullDefaultAnnotationType = Internal + 927;
1811 /** @since 3.8 */
1812 int RedundantNullDefaultAnnotationMethod = Internal + 928;
1813 /** @since 3.8 */
1814 int ContradictoryNullAnnotations = Internal + 929;
1815 /** @since 3.8 */
1816 int MissingNonNullByDefaultAnnotationOnType = Internal + 930; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=372012
1817 /** @since 3.8 */
1818 int RedundantNullCheckOnSpecdNonNullLocalVariable = Internal + 931;
1819 /** @since 3.8 */
1820 int SpecdNonNullLocalVariableComparisonYieldsFalse = Internal + 932;
1821 /** @since 3.8 */
1822 int RequiredNonNullButProvidedSpecdNullable = Internal + 933;
1823 /** @since 3.9 */
1824 int UninitializedNonNullField = FieldRelated + 934;
1825 /** @since 3.9 */
1826 int UninitializedNonNullFieldHintMissingDefault = FieldRelated + 935;
1827 /** @since 3.9 */
1828 int NonNullMessageSendComparisonYieldsFalse = Internal + 936;
1829 /** @since 3.9 */
1830 int RedundantNullCheckOnNonNullSpecdField = Internal + 937;
1831 /** @since 3.9 */
1832 int NonNullSpecdFieldComparisonYieldsFalse = Internal + 938;
1833 /** @since 3.9 */
1834 int ConflictingNullAnnotations = MethodRelated + 939;
1835 /** @since 3.9 */
1836 int ConflictingInheritedNullAnnotations = MethodRelated + 940;
1837 /** @since 3.10 */
1838 int RedundantNullCheckOnField = Internal + 941;
1839 /** @since 3.10 */
1840 int FieldComparisonYieldsFalse = Internal + 942;
1841 /** @since 3.14 */
1842 int RedundantNullDefaultAnnotationModule = Internal + 943;
1843 /** @since 3.19 */
1844 int RedundantNullCheckOnConstNonNullField = Internal + 944;
1845 /** @since 3.20 */
1846 int ConstNonNullFieldComparisonYieldsFalse = Internal + 945;
1847 /** @since 3.21 */
1848 int InheritedParameterLackingNonNullAnnotation = MethodRelated + 946;
1849
1850 /** @since 3.10 */
1851 int ArrayReferencePotentialNullReference = Internal + 951;
1852 /** @since 3.10 */
1853 int DereferencingNullableExpression = Internal + 952;
1854 /** @since 3.10 */
1855 int NullityMismatchingTypeAnnotation = Internal + 953;
1856 /** @since 3.10 */
1857 int NullityMismatchingTypeAnnotationSuperHint = Internal + 954;
1858 /** @since 3.10 */
1859 int NullityUncheckedTypeAnnotationDetail = Internal + 955;
1860 /** @since 3.10 */
1861 int NullityUncheckedTypeAnnotationDetailSuperHint = Internal + 956;
1862 /** @since 3.10 */
1863 int ReferenceExpressionParameterNullityMismatch = MethodRelated + 957;
1864 /** @since 3.10 */
1865 int ReferenceExpressionParameterNullityUnchecked = MethodRelated + 958;
1866 /** @since 3.10 */
1867 int ReferenceExpressionReturnNullRedef = MethodRelated + 959;
1868 /** @since 3.10 */
1869 int ReferenceExpressionReturnNullRedefUnchecked = MethodRelated + 960;
1870 /** @since 3.10 */
1871 int RedundantNullCheckAgainstNonNullType = Internal + 961;
1872 /** @since 3.10 */
1873 int NullAnnotationUnsupportedLocation = Internal + 962;
1874 /** @since 3.10 */
1875 int NullAnnotationUnsupportedLocationAtType = Internal + 963;
1876 /** @since 3.10 */
1877 int NullityMismatchTypeArgument = Internal + 964;
1878 /** @since 3.10 */
1879 int ContradictoryNullAnnotationsOnBound = Internal + 965;
1880 /** @since 3.10 */
1881 int ContradictoryNullAnnotationsInferred = Internal + 966;
1882 /** @since 3.10 */
1883 int UnsafeNullnessCast = Internal + 967;
1884 /** @since 3.10 */
1885 int NonNullDefaultDetailIsNotEvaluated = 968; // no longer reported
1886 /** @since 3.10 */
1887 int NullNotCompatibleToFreeTypeVariable = 969;
1888 /** @since 3.10 */
1889 int NullityMismatchAgainstFreeTypeVariable = 970;
1890 /** @since 3.11 */
1891 int ImplicitObjectBoundNoNullDefault = 971;
1892 /** @since 3.11 */
1893 int IllegalParameterNullityRedefinition = MethodRelated + 972;
1894 /** @since 3.11 */
1895 int ContradictoryNullAnnotationsInferredFunctionType = MethodRelated + 973;
1896 /** @since 3.11 */
1897 int IllegalReturnNullityRedefinitionFreeTypeVariable = MethodRelated + 974;
1898 /** @since 3.12 */
1899 int IllegalRedefinitionOfTypeVariable = 975;
1900 /** @since 3.12 */
1901 int UncheckedAccessOfValueOfFreeTypeVariable = 976;
1902 /** @since 3.12 */
1903 int UninitializedFreeTypeVariableField = 977;
1904 /** @since 3.12 */
1905 int UninitializedFreeTypeVariableFieldHintMissingDefault = 978;
1906 /** @since 3.12 */
1907 int RequiredNonNullButProvidedFreeTypeVariable = TypeRelated + 979;
1908 /** @since 3.12 */
1909 int NonNullTypeVariableFromLegacyMethod = TypeRelated + 980;
1910 /** @since 3.12 */
1911 int NonNullMethodTypeVariableFromLegacyMethod = TypeRelated + 981;
1912 /** @since 3.21 */
1913 int MissingNullAnnotationImplicitlyUsed = Internal + 982;
1914 /** @since 3.21 */
1915 int AnnotatedTypeArgumentToUnannotated = Internal + 983;
1916 /** @since 3.21 */
1917 int AnnotatedTypeArgumentToUnannotatedSuperHint = Internal + 984;
1918
1919
1920 // Java 8 work
1921 /** @since 3.10 */
1922 int IllegalModifiersForElidedType = Internal + 1001;
1923 /** @since 3.10 */
1924 int IllegalModifiers = Internal + 1002;
1925
1926 /** @since 3.10 */
1927 int IllegalTypeArgumentsInRawConstructorReference = TypeRelated + 1003;
1928
1929 // more on lambdas:
1930 /** @since 3.18 */
1931 int MissingValueFromLambda = Internal + 1004;
1932
1933 // default methods:
1934 /** @since 3.10 */
1935 int IllegalModifierForInterfaceMethod18 = MethodRelated + 1050;
1936
1937 /** @since 3.10 */
1938 int DefaultMethodOverridesObjectMethod = MethodRelated + 1051;
1939
1940 /** @since 3.10 */
1941 int InheritedDefaultMethodConflictsWithOtherInherited = MethodRelated + 1052;
1942
1943 /** @since 3.10 */
1944 int DuplicateInheritedDefaultMethods = MethodRelated + 1053;
1945
1946 /** @since 3.10 */
1947 int SuperAccessCannotBypassDirectSuper = TypeRelated + 1054;
1948 /** @since 3.10 */
1949 int SuperCallCannotBypassOverride = MethodRelated + 1055;
1950 /** @since 3.10 */
1951 int IllegalModifierCombinationForInterfaceMethod = MethodRelated + 1056;
1952 /** @since 3.10 */
1953 int IllegalStrictfpForAbstractInterfaceMethod = MethodRelated + 1057;
1954 /** @since 3.10 */
1955 int IllegalDefaultModifierSpecification = MethodRelated + 1058;
1956 /** @since 3.13 */
1957 int CannotInferInvocationType = TypeRelated + 1059;
1958
1959
1960 /** @since 3.13 */
1961 int TypeAnnotationAtQualifiedName = Internal + Syntax + 1060;
1962
1963 /** @since 3.13 */
1964 int NullAnnotationAtQualifyingType = Internal + Syntax + 1061;
1965
1966 /** @since 3.14*/
1967 int IllegalModifierForInterfaceMethod9 = MethodRelated + 1071;
1968 /** @since 3.14*/
1969 int IllegalModifierCombinationForPrivateInterfaceMethod9 = MethodRelated + 1070;
1970 /** @since 3.14 */
1971 int UndefinedModule = ModuleRelated + 1300;
1972 /** @since 3.14 */
1973 int DuplicateRequires = ModuleRelated + 1301;
1974 /** @since 3.14 */
1975 int DuplicateExports = ModuleRelated + 1302;
1976 /** @since 3.14 */
1977 int DuplicateUses = ModuleRelated + 1303;
1978 /** @since 3.14 */
1979 int DuplicateServices = ModuleRelated + 1304;
1980 /** @since 3.14 */
1981 int CyclicModuleDependency = ModuleRelated + 1305;
1982 /** @since 3.14 */
1983 int AbstractServiceImplementation = TypeRelated + 1306;
1984 /** @since 3.14 */
1985 int ProviderMethodOrConstructorRequiredForServiceImpl = TypeRelated + 1307;
1986 /** @since 3.14 */
1987 int ServiceImplDefaultConstructorNotPublic = TypeRelated + 1308;
1988 /** @since 3.14 */
1989 int NestedServiceImpl = TypeRelated + 1309;
1990 /** @since 3.14 */
1991 int ServiceImplNotDefinedByModule = TypeRelated + 1310;
1992 /** @since 3.14 */
1993 int PackageDoesNotExistOrIsEmpty = ModuleRelated + 1311;
1994 /** @since 3.14 */
1995 int NonDenotableTypeArgumentForAnonymousDiamond = TypeRelated + 1312;
1996 /** @since 3.14 */
1997 int DuplicateOpens = ModuleRelated + 1313;
1998 /** @since 3.14 */
1999 int DuplicateModuleRef = ModuleRelated + 1314;
2000 /** @since 3.14 */
2001 int InvalidOpensStatement = ModuleRelated + 1315;
2002 /** @since 3.14 */
2003 int InvalidServiceIntfType = ModuleRelated + 1316;
2004 /** @since 3.14 */
2005 int InvalidServiceImplType = ModuleRelated + 1317;
2006 /** @since 3.14 */
2007 int IllegalModifierForModule = ModuleRelated + 1318;
2008 /** @since 3.18 */
2009 int UndefinedModuleAddReads = ModuleRelated + 1319;
2010 /** @since 3.20 */
2011 int ExportingForeignPackage = ModuleRelated + 1320;
2012
2013
2014 /** @since 3.14 */
2015 int DuplicateResource = Internal + 1251;
2016
2017 // terminally
2018 /** @since 3.14 */
2019 int UsingTerminallyDeprecatedType = TypeRelated + 1400;
2020 /** @since 3.14 */
2021 int UsingTerminallyDeprecatedMethod = MethodRelated + 1401;
2022 /** @since 3.14 */
2023 int UsingTerminallyDeprecatedConstructor = MethodRelated + 1402;
2024 /** @since 3.14 */
2025 int UsingTerminallyDeprecatedField = FieldRelated + 1403;
2026 /** @since 3.14 */
2027 int OverridingTerminallyDeprecatedMethod = MethodRelated + 1404;
2028 // with since
2029 /** @since 3.14 */
2030 int UsingDeprecatedSinceVersionType = TypeRelated + 1405;
2031 /** @since 3.14 */
2032 int UsingDeprecatedSinceVersionMethod = MethodRelated + 1406;
2033 /** @since 3.14 */
2034 int UsingDeprecatedSinceVersionConstructor = MethodRelated + 1407;
2035 /** @since 3.14 */
2036 int UsingDeprecatedSinceVersionField = FieldRelated + 1408;
2037 /** @since 3.14 */
2038 int OverridingDeprecatedSinceVersionMethod = MethodRelated + 1409;
2039 // terminally with since
2040 /** @since 3.14 */
2041 int UsingTerminallyDeprecatedSinceVersionType = TypeRelated + 1410;
2042 /** @since 3.14 */
2043 int UsingTerminallyDeprecatedSinceVersionMethod = MethodRelated + 1411;
2044 /** @since 3.14 */
2045 int UsingTerminallyDeprecatedSinceVersionConstructor = MethodRelated + 1412;
2046 /** @since 3.14 */
2047 int UsingTerminallyDeprecatedSinceVersionField = FieldRelated + 1413;
2048 /** @since 3.14 */
2049 int OverridingTerminallyDeprecatedSinceVersionMethod = MethodRelated + 1414;
2050
2051 // unused constants:
2052 /** @since 3.14 */
2053 int UsingDeprecatedPackage = ModuleRelated + 1425;
2054 /** @since 3.14 */
2055 int UsingDeprecatedSinceVersionPackage = ModuleRelated + 1426;
2056 /** @since 3.14 */
2057 int UsingTerminallyDeprecatedPackage = ModuleRelated + 1427;
2058 /** @since 3.14 */
2059 int UsingTerminallyDeprecatedSinceVersionPackage = ModuleRelated + 1428;
2060 // deprecation of modules:
2061 /** @since 3.14 */
2062 int UsingDeprecatedModule = ModuleRelated + 1429;
2063 /** @since 3.14 */
2064 int UsingDeprecatedSinceVersionModule = ModuleRelated + 1430;
2065 /** @since 3.14 */
2066 int UsingTerminallyDeprecatedModule = ModuleRelated + 1431;
2067 /** @since 3.14 */
2068 int UsingTerminallyDeprecatedSinceVersionModule = ModuleRelated + 1432;
2069
2070 /** @since 3.14 */
2071 int NotAccessibleType = TypeRelated + 1450;
2072 /** @since 3.14 */
2073 int NotAccessibleField = FieldRelated + 1451;
2074 /** @since 3.14 */
2075 int NotAccessibleMethod = MethodRelated + 1452;
2076 /** @since 3.14 */
2077 int NotAccessibleConstructor = MethodRelated + 1453;
2078 /** @since 3.14 */
2079 int NotAccessiblePackage = ImportRelated + 1454;
2080 /** @since 3.14 */
2081 int ConflictingPackageFromModules = ModuleRelated + 1455;
2082 /** @since 3.14 */
2083 int ConflictingPackageFromOtherModules = ModuleRelated + 1456;
2084 /** @since 3.14 */
2085 int NonPublicTypeInAPI = ModuleRelated + 1457;
2086 /** @since 3.14 */
2087 int NotExportedTypeInAPI = ModuleRelated + 1458;
2088 /** @since 3.14 */
2089 int MissingRequiresTransitiveForTypeInAPI = ModuleRelated + 1459;
2090 /** @since 3.14 */
2091 int UnnamedPackageInNamedModule = ModuleRelated + 1460;
2092 /** @since 3.14 */
2093 int UnstableAutoModuleName = ModuleRelated + 1461;
2094
2095 // doc variant of an above constant:
2096 /** @since 3.22 */
2097 int JavadocNotAccessibleType = Javadoc + NotAccessibleType;
2098
2099 /** @since 3.13 */
2100 int RedundantNullDefaultAnnotationLocal = Internal + 1062;
2101
2102 /** @since 3.13 */
2103 int RedundantNullDefaultAnnotationField = Internal + 1063;
2104
2105 /** @since 3.10 */
2106 int GenericInferenceError = 1100; // FIXME: This is just a stop-gap measure, be more specific via https://bugs.eclipse.org/404675
2107
2108 /** @deprecated - problem is no longer generated (implementation issue has been resolved)
2109 * @since 3.10 */
2110 int LambdaShapeComputationError = 1101;
2111 /** @since 3.13 */
2112 int ProblemNotAnalysed = 1102;
2113 /** @since 3.18 */
2114 int PreviewFeatureDisabled = Compliance + 1103;
2115 /** @since 3.18 */
2116 int PreviewFeatureUsed = Compliance + 1104;
2117 /** @since 3.18 */
2118 int PreviewFeatureNotSupported = Compliance + 1105;
2119 /** @since 3.20*/
2120 int PreviewFeaturesNotAllowed = PreviewRelated + 1106;
2121
2122 /** @since 3.13 */
2123 int UnlikelyCollectionMethodArgumentType = 1200;
2124 /** @since 3.13 */
2125 int UnlikelyEqualsArgumentType = 1201;
2126
2127 /* Local-Variable Type Inference */
2128 /** @since 3.14 */
2129 int VarLocalMultipleDeclarators = Syntax + 1500; // ''var'' is not allowed in a compound declaration
2130 /** @since 3.14 */
2131 int VarLocalCannotBeArray = Syntax + 1501; // ''var'' is not allowed as an element type of an array
2132 /** @since 3.14 */
2133 int VarLocalReferencesItself = Syntax + 1502; // Declaration using ''var'' may not contin references to itself
2134 /** @since 3.14 */
2135 int VarLocalWithoutInitizalier = Syntax + 1503; // Cannot use ''var'' on variable without initializer
2136 /** @since 3.14 */
2137 int VarLocalInitializedToNull = TypeRelated + 1504; // Variable initialized to ''null'' needs an explicit target-type
2138 /** @since 3.14 */
2139 int VarLocalInitializedToVoid = TypeRelated + 1505; // Variable initializer is ''void'' -- cannot infer variable type
2140 /** @since 3.14 */
2141 int VarLocalCannotBeArrayInitalizers = TypeRelated + 1506; // Array initializer needs an explicit target-type
2142 /** @since 3.14 */
2143 int VarLocalCannotBeLambda = TypeRelated + 1507; // Lambda expression needs an explicit target-type
2144 /** @since 3.14 */
2145 int VarLocalCannotBeMethodReference = TypeRelated + 1508; // Method reference needs an explicit target-type
2146 /** @since 3.14 */
2147 int VarIsReserved = Syntax + 1509; // ''var'' is not a valid type name
2148 /** @since 3.14 */
2149 int VarIsReservedInFuture = Syntax + 1510; // ''var'' should not be used as an type name, since it is a reserved word from source level 10 on
2150 /** @since 3.14 */
2151 int VarIsNotAllowedHere = Syntax + 1511; // ''var'' is not allowed here
2152 /** @since 3.16 */
2153 int VarCannotBeMixedWithNonVarParams = Syntax + 1512; // ''var'' cannot be mixed with explicit or implicit parameters
2154 /** @since 3.18
2155 * @deprecated preview related error - will be removed
2156 * @noreference preview related error */
2157 int SwitchExpressionsIncompatibleResultExpressionTypes = TypeRelated + 1600;
2158 /** @since 3.18
2159 * @deprecated preview related error - will be removed
2160 * @noreference preview related error */
2161 int SwitchExpressionsEmptySwitchBlock = Internal + 1601;
2162 /** @since 3.18
2163 * @deprecated preview related error - will be removed
2164 * @noreference preview related error */
2165 int SwitchExpressionsNoResultExpression = TypeRelated + 1602;
2166 /** @since 3.18
2167 * @deprecated preview related error - will be removed
2168 * @noreference preview related error */
2169 int SwitchExpressionSwitchLabeledBlockCompletesNormally = Internal + 1603;
2170 /** @since 3.18
2171 * @deprecated preview related error - will be removed
2172 * @noreference preview related error */
2173 int SwitchExpressionLastStatementCompletesNormally = Internal + 1604;
2174 /** @since 3.18
2175 * @deprecated preview related error - will be removed
2176 * @noreference preview related error */
2177 int SwitchExpressionTrailingSwitchLabels = Internal + 1605;
2178 /** @since 3.18
2179 * @deprecated preview related error - will be removed
2180 * @noreference preview related error */
2181 int switchMixedCase = Syntax + 1606;
2182 /** @since 3.18
2183 * @deprecated preview related error - will be removed
2184 * @noreference preview related error */
2185 int SwitchExpressionMissingDefaultCase = Internal + 1607;
2186 /** @since 3.18
2187 * @deprecated preview related error - will be removed
2188 * @noreference preview related error */
2189 int SwitchExpressionBreakMissingValue = Internal + 1610;
2190 /** @since 3.18
2191 * @deprecated preview related error - will be removed
2192 * @noreference preview related error */
2193 int SwitchExpressionMissingEnumConstantCase = Internal + 1611;
2194 /** @since 3.18
2195 * @deprecated preview related error - will be removed
2196 * @noreference preview related error */
2197 int SwitchExpressionIllegalLastStatement = Internal + 1612;
2198
2199 /* Java14 errors - begin */
2200 /** @since 3.21 */
2201 int SwitchExpressionsYieldIncompatibleResultExpressionTypes = TypeRelated + 1700;
2202 /** @since 3.21 */
2203 int SwitchExpressionsYieldEmptySwitchBlock = Syntax + 1701;
2204 /** @since 3.21 */
2205 int SwitchExpressionsYieldNoResultExpression = Internal + 1702;
2206 /** @since 3.21 */
2207 int SwitchExpressionaYieldSwitchLabeledBlockCompletesNormally = Internal + 1703;
2208 /** @since 3.21 */
2209 int SwitchExpressionsYieldLastStatementCompletesNormally = Internal + 1704;
2210 /** @since 3.21 */
2211 int SwitchExpressionsYieldTrailingSwitchLabels = Internal + 1705;
2212 /** @since 3.21 */
2213 int SwitchPreviewMixedCase = Syntax + 1706;
2214 /** @since 3.21 */
2215 int SwitchExpressionsYieldMissingDefaultCase = Syntax + 1707;
2216 /** @since 3.21 */
2217 int SwitchExpressionsYieldMissingValue = Syntax + 1708;
2218 /** @since 3.21 */
2219 int SwitchExpressionsYieldMissingEnumConstantCase = Syntax + 1709;
2220 /** @since 3.21 */
2221 int SwitchExpressionsYieldIllegalLastStatement = Internal + 1710;
2222 /** @since 3.21 */
2223 int SwitchExpressionsYieldBreakNotAllowed = Syntax + 1711;
2224 /** @since 3.21 */
2225 int SwitchExpressionsYieldUnqualifiedMethodWarning = Syntax + 1712;
2226 /** @since 3.21 */
2227 int SwitchExpressionsYieldUnqualifiedMethodError = Syntax + 1713;
2228 /** @since 3.21 */
2229 int SwitchExpressionsYieldOutsideSwitchExpression = Syntax + 1714;
2230 /** @since 3.21 */
2231 int SwitchExpressionsYieldRestrictedGeneralWarning = Internal + 1715;
2232 /** @since 3.21 */
2233 int SwitchExpressionsYieldIllegalStatement = Internal + 1716;
2234 /** @since 3.21 */
2235 int SwitchExpressionsYieldTypeDeclarationWarning = Internal + 1717;
2236 /** @since 3.21 */
2237 int SwitchExpressionsYieldTypeDeclarationError = Internal + 1718;
2238 /** @since 3.22 */
2239 int MultiConstantCaseLabelsNotSupported = Syntax + 1719;
2240 /** @since 3.22*/
2241 int ArrowInCaseStatementsNotSupported = Syntax + 1720;
2242 /** @since 3.22 */
2243 int SwitchExpressionsNotSupported = Syntax + 1721;
2244 /** @since 3.22 */
2245 int SwitchExpressionsBreakOutOfSwitchExpression = Syntax + 1722;
2246 /** @since 3.22 */
2247 int SwitchExpressionsContinueOutOfSwitchExpression = Syntax + 1723;
2248 /** @since 3.22 */
2249 int SwitchExpressionsReturnWithinSwitchExpression = Syntax + 1724;
2250 /* records - begin */
2251
2252 /** @since 3.22
2253 * @noreference preview feature error */
2254 int RecordIllegalModifierForInnerRecord = PreviewRelated + 1730;
2255 /** @since 3.22
2256 * @noreference preview feature error */
2257 int RecordIllegalModifierForRecord = PreviewRelated + 1731;
2258 /** @since 3.22
2259 * JLS 14 Sec 8.10.1
2260 * it is always a compile-time error for a record header to declare a record component with the name
2261 * finalize, getClass, hashCode, notify, notifyAll, or toString. */
2262 int RecordIllegalComponentNameInRecord = PreviewRelated + 1732;
2263 /** @since 3.22
2264 * @noreference preview feature error */
2265 int RecordNonStaticFieldDeclarationInRecord = PreviewRelated + 1733;
2266 /** @since 3.22
2267 * @noreference preview feature error */
2268 int RecordAccessorMethodHasThrowsClause = PreviewRelated + 1734;
2269 /** @since 3.22
2270 * @noreference preview feature error */
2271 int RecordCanonicalConstructorHasThrowsClause = PreviewRelated + 1735;
2272 /** @since 3.22
2273 * @noreference preview feature error */
2274 int RecordCanonicalConstructorShouldBePublic = PreviewRelated + 1736;
2275 /** @since 3.22
2276 * @noreference preview feature error */
2277 int RecordMultipleCanonicalConstructors = PreviewRelated + 1737;
2278 /** @since 3.22
2279 * @noreference preview feature error */
2280 int RecordCompactConstructorHasReturnStatement = PreviewRelated + 1738;
2281 /** @since 3.22
2282 * @noreference preview feature error */
2283 int RecordDuplicateComponent = PreviewRelated + 1739;
2284 /** @since 3.22
2285 * @noreference preview feature error */
2286 int RecordIllegalNativeModifierInRecord = PreviewRelated + 1740;
2287 /** @since 3.22
2288 * @noreference preview feature error */
2289 int RecordInstanceInitializerBlockInRecord = PreviewRelated + 1741;
2290 /** @since 3.22
2291 * @noreference preview feature error */
2292 int RecordIsAReservedTypeName = PreviewRelated + 1742;
2293 /** @since 3.22
2294 * @noreference preview feature error */
2295 int RecordIllegalAccessorReturnType = PreviewRelated + 1743;
2296 /** @since 3.22
2297 * @noreference preview feature error */
2298 int RecordAccessorMethodShouldNotBeGeneric = PreviewRelated + 1744;
2299 /** @since 3.22
2300 * @noreference preview feature error */
2301 int RecordAccessorMethodShouldBePublic = PreviewRelated + 1745;
2302 /** @since 3.22
2303 * @noreference preview feature error */
2304 int RecordCanonicalConstructorShouldNotBeGeneric = PreviewRelated + 1746;
2305 /** @since 3.22
2306 * @noreference preview feature error */
2307 int RecordCanonicalConstructorHasReturnStatement = PreviewRelated + 1747;
2308 /** @since 3.22
2309 * @noreference preview feature error */
2310 int RecordCanonicalConstructorHasExplicitConstructorCall = PreviewRelated + 1748;
2311 /** @since 3.22
2312 * @noreference preview feature error */
2313 int RecordCompactConstructorHasExplicitConstructorCall = PreviewRelated + 1749;
2314 /** @since 3.22
2315 * @noreference preview feature error */
2316 int RecordNestedRecordInherentlyStatic = PreviewRelated + 1750;
2317 /** @since 3.22
2318 * @noreference preview feature error */
2319 int RecordAccessorMethodShouldNotBeStatic= PreviewRelated + 1751;
2320 /** @since 3.22
2321 * @noreference preview feature error */
2322 int RecordCannotExtendRecord= PreviewRelated + 1752;
2323 /** @since 3.22
2324 * @noreference preview feature error */
2325 int RecordComponentCannotBeVoid= PreviewRelated + 1753;
2326 /** @since 3.22
2327 * @noreference preview feature error */
2328 int RecordIllegalVararg= PreviewRelated + 1754;
2329 /** @since 3.22
2330 * @noreference preview feature error */
2331 int RecordStaticReferenceToOuterLocalVariable= PreviewRelated + 1755;
2332 /** @since 3.22
2333 * @noreference preview feature error */
2334 int RecordCannotDefineRecordInLocalType= PreviewRelated + 1756;
2335 /* records - end */
2336 /* instanceof pattern: */
2337 /** @since 3.22
2338 * @noreference preview feature error */
2339 int PatternVariableNotInScope = PreviewRelated + 1760;
2340 /* Java14 errors - end */
2341 }
2342