When generated, this attribute will enable local variable names + * to be displayed in debugger, only in place where variables are + * definitely assigned (.class file is then bigger). + *
"org.eclipse.jdt.core.compiler.debug.localVariable"{ "generate", "do not generate" }"generate"When generated, this attribute will enable source code highlighting in debugger + * (.class file is then bigger). + *
"org.eclipse.jdt.core.compiler.debug.lineNumber"{ "generate", "do not generate" }"generate"When generated, this attribute will enable the debugger to present the + * corresponding source code. + *
"org.eclipse.jdt.core.compiler.debug.sourceFile"{ "generate", "do not generate" }"generate"Unless requested to preserve unused local variables (that is, never read), the + * compiler will optimize them out, potentially altering debugging. + *
"org.eclipse.jdt.core.compiler.codegen.unusedLocal"{ "preserve", "optimize out" }"preserve"For binary compatibility reason, .class files can be tagged to with certain VM versions and later. + *
Note that "1.4" target requires to toggle compliance mode to "1.4", "1.5" target requires
+ * to toggle compliance mode to "1.5", "1.6" target requires to toggle compliance mode to "1.6" and
+ * "1.7" target requires to toggle compliance mode to "1.7".
+ * "cldc1.1" requires the source version to be "1.3" and the compliance version to be "1.4" or lower.
+ *
"org.eclipse.jdt.core.compiler.codegen.targetPlatform"{ "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "cldc1.1" }"1.2"When enabled, the compiler will no longer generate JSR instructions, but rather inline corresponding + * subroutine code sequences (mostly corresponding to try finally blocks). The generated code will thus + * get bigger, but will load faster on virtual machines since the verification process is then much simpler. + *
This mode is anticipating support for the Java Specification Request 202. + *
Note that JSR inlining is optional only for target platform lesser than 1.5. From 1.5 on, the JSR + * inlining is mandatory (also see related setting {@link #COMPILER_CODEGEN_TARGET_PLATFORM}). + *
"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"{ "enabled", "disabled" }"disabled"When this support is disabled, the compiler will ignore all javadoc problems options settings + * and will not report any javadoc problem. It will also not find any reference in javadoc comment and + * DOM AST Javadoc node will be only a flat text instead of having structured tag elements. + *
"org.eclipse.jdt.core.compiler.doc.comment.support"{ "enabled", "disabled" }"enabled"A package visible method, which is any method that is not explicitly + * declared as public, protected or private, is not visible from other + * packages, and thus cannot be overridden from another package. + * Attempting to override a package visible method from another package + * introduces a new method that is unrelated to the original one. When + * enabling this option, the compiler will signal such situations as an + * error or a warning. + *
"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"{ "error", "warning", "ignore" }"warning"Naming a method with a constructor name is generally considered poor + * style programming. When enabling this option, the compiler will signal such + * scenarii either as an error or a warning. + *
"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will signal use of deprecated API either as an + * error or a warning. + *
"org.eclipse.jdt.core.compiler.problem.deprecation"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will signal use of deprecated API inside deprecated code. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}. + *
"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"{ "enabled", "disabled" }"disabled"When enabled, the compiler will signal use of deprecated API in non + * deprecated code. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}. + *
"org.eclipse.jdt.core.compiler.problem.deprecationInNonDeprecatedCode"{ "enabled", "disabled" }"enabled"When enabled, the compiler will signal the declaration of a method overriding a deprecated one. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}. + *
"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"{ "enabled", "disabled" }"disabled"+ * Locally to a try statement, some catch blocks may hide others. For example, + *
+ * try { throw new java.io.CharConversionException();
+ * } catch (java.io.CharConversionException e) {
+ * } catch (java.io.IOException e) {}.
+ *
+ * When enabling this option, the compiler will issue an error or a warning for hidden
+ * catch blocks corresponding to checked exceptions.
+ * "org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning for unused local + * variables (that is, variables never read from). + *
"org.eclipse.jdt.core.compiler.problem.unusedLocal"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning for unused method + * parameters (that is, parameters never read from). + *
"org.eclipse.jdt.core.compiler.problem.unusedParameter"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will signal unused parameters in abstract method implementations. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}. + *
"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"{ "enabled", "disabled" }"disabled"When enabled, the compiler will signal unused parameters in methods overriding concrete ones. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}. + *
"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"{ "enabled", "disabled" }"disabled"When enabled, the compiler will consider doc comment references to parameters (i.e. @param clauses) for the unused
+ * parameter check. Thus, documented parameters will be considered as mandated as per doc contract.
+ *
The severity of the unused parameter problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}. + *
Note: this option has no effect until the doc comment support is enabled according to the + * option {@link #COMPILER_DOC_COMMENT_SUPPORT}. + *
"org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference"{ "enabled", "disabled" }"enabled"When enabled, the compiler will issue an error or a warning for unused import + * reference. + *
"org.eclipse.jdt.core.compiler.problem.unusedImport"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever type arguments are encountered for a
+ * non-generic method invocation. Note that prior to compliance level is "1.7", this situation would automatically result
+ * in an error. From Java7 on, unused type arguments are being tolerated, and optionally warned against.
+ *
"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever it emulates + * access to a non-accessible member of an enclosing type. Such access can have + * performance implications. + *
"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning for non externalized
+ * String literal (that is, not tagged with //$NON-NLS-<n>$).
+ *
"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"{ "error", "warning", "ignore" }"ignore"'assert' Identifier.
+ * When enabled, the compiler will issue an error or a warning whenever 'assert' is
+ * used as an identifier (reserved keyword in 1.4).
+ *
"org.eclipse.jdt.core.compiler.problem.assertIdentifier"{ "error", "warning", "ignore" }"warning"'enum' Identifier.
+ * When enabled, the compiler will issue an error or a warning whenever 'enum' is
+ * used as an identifier (reserved keyword in 1.5).
+ *
"org.eclipse.jdt.core.compiler.problem.enumIdentifier"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a static field + * or method is accessed with an expression receiver. A reference to a static member should + * be qualified with a type name. + *
"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a static field + * or method is accessed in an indirect way. A reference to a static member should + * preferably be qualified with its declaring type name. + *
"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning whenever an assignment
+ * has no effect (e.g 'x = x').
+ *
"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever an interface
+ * defines a method incompatible with a non-inherited Object method. Until this conflict
+ * is resolved, such an interface cannot be implemented, For example,
+ *
+ * interface I {
+ * int clone();
+ * }
+ *
+ * "org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a private + * method or field is declared but never used within the same unit. + *
"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning whenever a local variable + * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type). + *
"org.eclipse.jdt.core.compiler.problem.localVariableHiding"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will signal cases where a constructor or setter method parameter declaration + * is hiding some field (either locally, inherited or defined in enclosing type). + *
The severity of the problem is controlled with option {@link #COMPILER_PB_LOCAL_VARIABLE_HIDING}. + *
"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"{ "enabled", "disabled" }"disabled"When enabled, the compiler will issue an error or a warning whenever a field + * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type). + *
"org.eclipse.jdt.core.compiler.problem.fieldHiding"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning in situations where a type parameter + * declaration is hiding some type, when a nested type is hiding some type parameter, or when + * a nested type is hiding another nested type defined in same unit. + *
"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning if a boolean assignment is acting as the condition + * of a control statement (where it probably was meant to be a boolean comparison). + *
"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning if a case may be + * entered by falling through previous case. Empty cases are allowed. + *
"org.eclipse.jdt.core.compiler.problem.fallthroughCase"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning if an empty statement or a + * unnecessary semicolon is encountered. + *
"org.eclipse.jdt.core.compiler.problem.emptyStatement"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning when a cast or an instanceof operation
+ * is unnecessary.
+ *
"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning when a statement is unnecessarily
+ * nested within an else clause (in situation where then clause is not completing normally).
+ *
"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning when an empty block is detected and it is not + * documented with any comment. + *
"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning when a finally block does not complete normally. + *
"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning when a + * method or a constructor is declaring a thrown exception, but never + * actually raises it in its body. Depending on + * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_UNCHECKED_EXCEPTIONS}, + * only checked exceptions will be considered (default), or all + * exceptions, including unchecked ones, will be considered. + *
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"{ "error", "warning", "ignore" }"ignore"When disabled, the compiler will report unused declared thrown + * exceptions neither on overriding methods nor on implementing methods. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}. + *
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"{ "enabled", "disabled" }"disabled"When enabled, the compiler will consider doc comment references to exceptions (i.e. @throws clauses) for the unused
+ * declared thrown exception check. Thus, documented exceptions will be considered as mandated as per doc contract.
+ *
The severity of the unused declared thrown exception problem is controlled with option {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}. + *
Note: this option has no effect until the doc comment support is enabled according to the + * option {@link #COMPILER_DOC_COMMENT_SUPPORT}. + *
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"{ "enabled", "disabled" }"enabled"When enabled, the compiler will report unused declared thrown + * exceptions for all exceptions, including unchecked ones. When + * disabled, only checked exceptions will be considered. + *
The severity of the problem is controlled with option + * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}. + *
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeUncheckedExceptions"{ "enabled", "disabled" }"disabled"When enabled, the compiler will issue an error or a warning when a field is access without any qualification.
+ * In order to improve code readability, it should be qualified, e.g. 'x' should rather be written 'this.x'.
+ *
"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning whenever an operation involves generic types, and potentially
+ * invalidates type safety since involving raw types (e.g. invoking #foo(X<String>) with arguments (X)).
+ *
"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning when detecting references to raw types. Raw types are + * discouraged, and are intended to help interfacing with legacy code. In the future, the language specification may + * reject raw references to generic types. + *
"org.eclipse.jdt.core.compiler.problem.rawTypeReference"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a generic type parameter is associated with a + * bound corresponding to a final type; since final types cannot be further extended, the parameter is pretty useless. + *
"org.eclipse.jdt.core.compiler.problem.finalParameterBound"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a serializable class is missing a local declaration
+ * of a serialVersionUID field. This field must be declared as static final and be of type long.
+ *
"org.eclipse.jdt.core.compiler.problem.missingSerialVersion"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a varargs arguments should be cast
+ * when passed to a method/constructor invocation. (e.g. Class.getMethod(String name, Class ... args )
+ * invoked with arguments ("foo", null)).
+ *
"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing + * conversion is performed. + *
"org.eclipse.jdt.core.compiler.problem.autoboxing"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning whenever an annotation type is used + * as a super-interface. Though legal, this is discouraged. + *
"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"{ "error", "warning", "ignore" }"warning"@Override Annotation.
+ * When enabled, the compiler will issue an error or a warning whenever encountering a method
+ * declaration which overrides a superclass method but has no @Override annotation.
+ *
"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"{ "error", "warning", "ignore" }"ignore"@Deprecated Annotation.
+ * When enabled, the compiler will issue an error or a warning whenever encountering a declaration
+ * carrying a @deprecated doc tag but having no corresponding @Deprecated annotation.
+ *
"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning whenever + * an enum constant has no corresponding case label in an enum switch + * statement. + *
"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning when encountering a labeled statement which label
+ * is never explicitly referenced. A label is considered to be referenced if its name explicitly appears behind a break
+ * or continue statement; for instance the following label would be considered unreferenced:
+ * LABEL: { break; }
+ *
"org.eclipse.jdt.core.compiler.problem.unusedLabel"{ "error", "warning", "ignore" }"warning"This is the generic control for the severity of Javadoc problems. + * When enabled, the compiler will issue an error or a warning for a problem in Javadoc. + *
"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will signal unbound or unexpected reference tags in Javadoc.
+ * A @throws tag referencing an undeclared exception would be considered as unexpected.
+ *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; + * also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}. + * * @since 3.0 + * @category CompilerOptionID */ public static final String COMPILER_PB_INVALID_JAVADOC_TAGS = PLUGIN_ID + ".compiler.problem.invalidJavadocTags"; //$NON-NLS-1$ /** - * Possible configurable option ID. - * @see #getDefaultOptions() + * Compiler option ID: Reporting Invalid Javadoc Tags with Deprecated References. + *
Specify whether the compiler will report deprecated references used in Javadoc tags. + *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; + * also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}. + *
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"{ "enabled", "disabled" }"disabled"Specify whether the compiler will report non-visible references used in Javadoc tags. + *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; + * also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}. + *
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"{ "enabled", "disabled" }"disabled"Set the minimum visibility level for Javadoc tag problems. Below this level problems will be ignored. + *
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"{ "public", "protected", "default", "private" }"public"When enabled, the compiler will report a warning or an error for any Javadoc missing a required description. + *
The severity of the problem is controlled with option {@link #COMPILER_PB_INVALID_JAVADOC}. + *
This option is NOT dependent from the Report errors in tags option. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription"{ "return_tag", "all_tags", "no_tag" }"return_tag"This is the generic control for the severity of Javadoc missing tag problems. + * When enabled, the compiler will issue an error or a warning when tags are missing in Javadoc comments. + *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; + * also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY}. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"{ "error", "warning", "ignore" }"ignore"Set the minimum visibility level for Javadoc missing tag problems. Below this level problems will be ignored. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"{ "public", "protected", "default", "private" }"public"Specify whether the compiler will verify overriding methods in order to report Javadoc missing tag problems. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"{ "enabled", "disabled" }"disabled"This is the generic control for the severity of missing Javadoc comment problems. + * When enabled, the compiler will issue an error or a warning when Javadoc comments are missing. + *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the expected Javadoc; + * also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY}. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"{ "error", "warning", "ignore" }"ignore"Set the minimum visibility level for missing Javadoc problems. Below this level problems will be ignored. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"{ "public", "protected", "default", "private" }"public"Specify whether the compiler will verify overriding methods in order to report missing Javadoc comment problems. + *
"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"{ "enabled", "disabled" }"disabled"char[] Expressions in String Concatenations.
+ * When enabled, the compiler will issue an error or a warning whenever a char[] expression
+ * is used in String concatenations (for example, "hello" + new char[]{'w','o','r','l','d'}).
+ *
"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"{ "error", "warning", "ignore" }"warning"Specify the maximum number of problems reported on each compilation unit. + *
"org.eclipse.jdt.core.compiler.maxProblemPerUnit""<n>" where <n> is zero or a positive integer (if zero then all problems are reported)."100"When enabled, optional errors (i.e. optional problems which severity is set to "error") will be treated as standard
+ * compiler errors, yielding problem methods/types preventing from running offending code until the issue got resolved.
+ *
When disabled, optional errors are only considered as warnings, still carrying an error indication to make them more + * severe. Note that by default, errors are fatal, whether they are optional or not. + *
"org.eclipse.jdt.core.compiler.problem.fatalOptionalError"{ "enabled", "disabled" }"enabled"When enabled, the compiler will issue an error or a warning if a parameter is + * assigned to. + *
"org.eclipse.jdt.core.compiler.problem.parameterAssignment"{ "error", "warning", "ignore" }"ignore"Specify whether which source level compatibility is used. From 1.4 on, 'assert' is a keyword
+ * reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM
+ * level should be set to "1.4" and the compliance mode should be "1.4".
+ *
Source level 1.5 is necessary to enable generics, autoboxing, covariance, annotations, enumerations
+ * enhanced for loop, static imports and varargs. Once toggled, the target VM level should be set to "1.5"
+ * and the compliance mode should be "1.5".
+ *
Source level 1.6 is necessary to enable the computation of stack map tables. Once toggled, the target
+ * VM level should be set to "1.6" and the compliance mode should be "1.6".
+ *
Once the source level 1.7 is toggled, the target VM level should be set to "1.7" and the compliance mode
+ * should be "1.7".
+ *
"org.eclipse.jdt.core.compiler.source"{ "1.3", "1.4", "1.5", "1.6", "1.7" }"1.3"Select the compliance level for the compiler. In "1.3" mode, source and target settings
+ * should not go beyond "1.3" level.
+ *
"org.eclipse.jdt.core.compiler.compliance"{ "1.3", "1.4", "1.5", "1.6", "1.7" }"1.4"In parallel with the Automatic Task Tags, this list defines the priorities (high, normal or low)
+ * of the task markers issued by the compiler.
+ * If the default is specified, the priority of each task marker is "NORMAL".
+ *
"org.eclipse.jdt.core.compiler.taskPriorities"{ "<priority>[,<priority>]*" } where <priority> is one of "HIGH", "NORMAL" or "LOW""NORMAL,HIGH,NORMAL"When the tag list is not empty, the compiler will issue a task marker whenever it encounters + * one of the corresponding tags inside any comment in Java source code. + *
Generated task messages will start with the tag, and range until the next line separator, + * comment ending, or tag. + *
When a given line of code bears multiple tags, each tag will be reported separately. + * Moreover, a tag immediately followed by another tag will be reported using the contents of the + * next non-empty tag of the line, if any. + *
Note that tasks messages are trimmed. If a tag is starting with a letter or digit, then it cannot be leaded by
+ * another letter or digit to be recognized ("fooToDo" will not be recognized as a task for tag "ToDo", but "foo#ToDo"
+ * will be detected for either tag "ToDo" or "#ToDo"). Respectively, a tag ending with a letter or digit cannot be followed
+ * by a letter or digit to be recognized ("ToDofoo" will not be recognized as a task for tag "ToDo", but "ToDo:foo" will
+ * be detected either for tag "ToDo" or "ToDo:").
+ *
"org.eclipse.jdt.core.compiler.taskTags"{ "<tag>[,<tag>]*" } where <tag> is a String without any wild-card or leading/trailing spaces"TODO,FIXME,XXX"When enabled, task tags are considered in a case-sensitive way. + *
"org.eclipse.jdt.core.compiler.taskCaseSensitive"{ "enabled", "disabled" }"enabled"When enabled, the compiler will issue an error or a warning when referring to a type that is non accessible, as defined according + * to the access rule specifications. + *
"org.eclipse.jdt.core.compiler.problem.forbiddenReference"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning when referring to a type with discouraged access, as defined according + * to the access rule specifications. + *
"org.eclipse.jdt.core.compiler.problem.discouragedReference"{ "error", "warning", "ignore" }"warning"@SuppressWarnings.
+ * When enabled, the @SuppressWarnings annotation can be used to suppress some compiler warnings.
+ *
When disabled, all @SupressWarnings annotations are ignored; i.e., warnings are reported.
+ *
"org.eclipse.jdt.core.compiler.problem.suppressWarnings"{ "enabled", "disabled" }"enabled"@SuppressWarnings.
+ * When enabled, the compiler will issue an error or a warning when encountering a token
+ * it cannot handle inside a @SuppressWarnings annotation.
+ *
"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"{ "error", "warning", "ignore" }"warning"@SuppressWarnings.
+ * When enabled, the compiler will issue an error or a warning when encountering @SuppressWarnings annotation
+ * for which no corresponding warning got detected in the code. This diagnostic is provided to help developers to get
+ * rid of transient @SuppressWarnings no longer needed. Note that @SuppressWarnings("all") is still
+ * silencing the warning for unnecessary @SuppressWarnings, as it is the master switch to silence ALL warnings.
+ *
"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a + * variable that is statically known to hold a null value is used to + * access a field or method. + *
"org.eclipse.jdt.core.compiler.problem.nullReference"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning whenever a + * variable that has formerly been tested against null but is not (no more) + * statically known to hold a non-null value is used to access a field or + * method. + *
"org.eclipse.jdt.core.compiler.problem.potentialNullReference"{ "error", "warning", "ignore" }"warning"When enabled, the compiler will issue an error or a warning whenever a + * variable that is statically known to hold a null or a non-null value + * is tested against null. + *
"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning if a method is overriding a method without calling + * the super invocation. + *
"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"{ "error", "warning", "ignore" }"ignore"When enabled, the compiler will issue an error or a warning if a type + * explicitly implements an interface that is already implemented by any + * of its supertypes. + *
"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"{ "error", "warning", "ignore" }"ignore"Indicate whether JavaCore should enforce the project build order to be based on + * the classpath prerequisite chain. When requesting to compute, this takes over + * the platform default order (based on project references). + *
"org.eclipse.jdt.core.computeJavaBuildOrder"{ "compute", "ignore" }"ignore"Allow to specify some filters to control the resource copy process. + *
"org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"{ "<name>[,<name>]* } where <name> is a file name pattern (* and ? wild-cards allowed)
+ * or the name of a folder which ends with '/'""Indicate the severity of the problem reported when more than one occurrence + * of a resource is to be copied into the output location. + *
"org.eclipse.jdt.core.builder.duplicateResourceTask"{ "error", "warning" }"warning"Indicate whether the JavaBuilder is allowed to clean the output folders + * when performing full build operations. + *
"org.eclipse.jdt.core.builder.cleanOutputFolder"{ "clean", "ignore" }"clean"Indicate whether the JavaBuilder should check for any changes to .class files + * in the output folders while performing incremental build operations. If changes + * are detected to managed .class files, then a full build is performed, otherwise + * the changes are left as is. Tools further altering generated .class files, like optimizers, + * should ensure this option remains set in its default state of ignore. + *
"org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"{ "enabled", "ignore" }"ignore"Indicate the severity of the problem reported when an entry on the classpath does not exist, + * is not legite or is not visible (for example, a referenced project is closed). + *
"org.eclipse.jdt.core.incompleteClasspath"{ "error", "warning"}"error"Indicate the severity of the problem reported when a project is involved in a cycle. + *
"org.eclipse.jdt.core.circularClasspath"{ "error", "warning" }"error"Indicate the severity of the problem reported when a project prerequisites another project + * or library with an incompatible target JDK level (e.g. project targeting 1.1 vm, but compiled against 1.4 libraries). + *
"org.eclipse.jdt.core.incompatibleJDKLevel"{ "error", "warning", "ignore" }"ignore"Allow to toggle the builder to abort if the classpath is invalid. + *
"org.eclipse.jdt.core.builder.invalidClasspath"{ "abort", "ignore" }"abort"Get the default encoding format of source files. This value is
+ * immutable and preset to the result of ResourcesPlugin.getEncoding().
+ *
It is offered as a convenience shortcut only. + *
"org.eclipse.jdt.core.encoding"<immutable, platform default value>When disabled, no entry on a project classpath can be associated with + * an exclusion pattern. + *
"org.eclipse.jdt.core.classpath.exclusionPatterns"{ "enabled", "disabled" }"enabled"When disabled, no entry on a project classpath can be associated with + * a specific output location, preventing thus usage of multiple output locations. + *
"org.eclipse.jdt.core.classpath.multipleOutputLocations"{ "enabled", "disabled" }"enabled"Timeout in milliseconds to retrieve the method's parameter names from javadoc. + *
If the value is 0, the parameter names are not fetched and the raw names are returned.
+ *
"org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc""<n>", where n is an integer greater than or equal to 0"50"When active, completion doesn't show that you can not see + * (for example, you can not see private methods of a super class). + *
"org.eclipse.jdt.core.codeComplete.visibilityCheck"{ "enabled", "disabled" }"disabled"When enabled, completion doesn't propose deprecated members and types. + *
"org.eclipse.jdt.core.codeComplete.deprecationCheck"{ "enabled", "disabled" }"disabled"When enabled, completion shows proposals whose name match the CamelCase + * pattern. + *
"org.eclipse.jdt.core.codeComplete.camelCaseMatch"{ "enabled", "disabled" }"enabled"When active, completion automatically qualifies completion on implicit + * field references and message expressions. + *
"org.eclipse.jdt.core.codeComplete.forceImplicitQualification"{ "enabled", "disabled" }"disabled"When the prefixes is non empty, completion for field name will begin with + * one of the proposed prefixes. + *
"org.eclipse.jdt.core.codeComplete.fieldPrefixes"{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card""When the prefixes is non empty, completion for static field name will begin with + * one of the proposed prefixes. + *
"org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card""When the prefixes is non empty, completion for local variable name will begin with + * one of the proposed prefixes. + *
"org.eclipse.jdt.core.codeComplete.localPrefixes"{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card""When the prefixes is non empty, completion for argument name will begin with + * one of the proposed prefixes. + *
"org.eclipse.jdt.core.codeComplete.argumentPrefixes"{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card""When the suffixes is non empty, completion for field name will end with + * one of the proposed suffixes. + *
"org.eclipse.jdt.core.codeComplete.fieldSuffixes"{ "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card""When the suffixes is non empty, completion for static field name will end with + * one of the proposed suffixes. + *
"org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"{ "<suffix>[,<suffix>]*" }< where <suffix> is a String without any wild-card""When the suffixes is non empty, completion for local variable name will end with + * one of the proposed suffixes. + *
"org.eclipse.jdt.core.codeComplete.localSuffixes"{ "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card""When the suffixes is non empty, completion for argument name will end with + * one of the proposed suffixes. + *
"org.eclipse.jdt.core.codeComplete.argumentSuffixes"{ "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card""When enabled, completion doesn't propose elements which match a + * forbidden reference rule. + *
"org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck"{ "enabled", "disabled" }"enabled"When enabled, completion doesn't propose elements which match a + * discouraged reference rule. + *
"org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck"{ "enabled", "disabled" }"disabled"When enabled, completion proposals can contain static import + * pattern. + *
"org.eclipse.jdt.core.codeComplete.suggestStaticImports"{ "enabled", "disabled" }"enabled"setOptions.
- *
- * Helper constants have been defined on JavaCore for each of the option ID and
- * their possible constant values.
- *
- * Note: more options might be added in further releases.
- *
- * RECOGNIZED OPTIONS:
- *
- * COMPILER / Setting Compliance Level
- * Select the compliance level for the compiler. In "1.3" mode, source and target settings
- * should not go beyond "1.3" level.
- * - option id: "org.eclipse.jdt.core.compiler.compliance"
- * - possible values: { "1.3", "1.4", "1.5", "1.6", "1.7" }
- * - default: "1.4"
- *
- * COMPILER / Setting Source Compatibility Mode
- * Specify whether which source level compatibility is used. From 1.4 on, 'assert' is a keyword
- * reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM
- * level should be set to "1.4" and the compliance mode should be "1.4".
- * Source level 1.5 is necessary to enable generics, autoboxing, covariance, annotations, enumerations
- * enhanced for loop, static imports and varargs. Once toggled, the target VM level should be set to "1.5"
- * and the compliance mode should be "1.5".
- * Source level 1.6 is necessary to enable the computation of stack map tables. Once toggled, the target
- * VM level should be set to "1.6" and the compliance mode should be "1.6".
- * Once the source level 1.7 is toggled, the target VM level should be set to "1.7" and the compliance mode
- * should be "1.7".
- * - option id: "org.eclipse.jdt.core.compiler.source"
- * - possible values: { "1.3", "1.4", "1.5", "1.6", "1.7" }
- * - default: "1.3"
- *
- * COMPILER / Defining Target Java Platform
- * For binary compatibility reason, .class files can be tagged to with certain VM versions and later.
- * Note that "1.4" target requires to toggle compliance mode to "1.4", "1.5" target requires
- * to toggle compliance mode to "1.5", "1.6" target requires to toggle compliance mode to "1.6" and
- * "1.7" target requires to toggle compliance mode to "1.7".
- * "cldc1.1" requires the source version to be "1.3" and the compliance version to be "1.4" or lower.
- * - option id: "org.eclipse.jdt.core.compiler.codegen.targetPlatform"
- * - possible values: { "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "cldc1.1" }
- * - default: "1.2"
- *
- * COMPILER / Generating Local Variable Debug Attribute
- * When generated, this attribute will enable local variable names
- * to be displayed in debugger, only in place where variables are
- * definitely assigned (.class file is then bigger)
- * - option id: "org.eclipse.jdt.core.compiler.debug.localVariable"
- * - possible values: { "generate", "do not generate" }
- * - default: "generate"
- *
- * COMPILER / Generating Line Number Debug Attribute
- * When generated, this attribute will enable source code highlighting in debugger
- * (.class file is then bigger).
- * - option id: "org.eclipse.jdt.core.compiler.debug.lineNumber"
- * - possible values: { "generate", "do not generate" }
- * - default: "generate"
- *
- * COMPILER / Generating Source Debug Attribute
- * When generated, this attribute will enable the debugger to present the
- * corresponding source code.
- * - option id: "org.eclipse.jdt.core.compiler.debug.sourceFile"
- * - possible values: { "generate", "do not generate" }
- * - default: "generate"
- *
- * COMPILER / Preserving Unused Local Variables
- * Unless requested to preserve unused local variables (that is, never read), the
- * compiler will optimize them out, potentially altering debugging
- * - option id: "org.eclipse.jdt.core.compiler.codegen.unusedLocal"
- * - possible values: { "preserve", "optimize out" }
- * - default: "preserve"
- *
- * COMPILER / Inline JSR Bytecode Instruction
- * When enabled, the compiler will no longer generate JSR instructions, but rather inline corresponding
- * subroutine code sequences (mostly corresponding to try finally blocks). The generated code will thus
- * get bigger, but will load faster on virtual machines since the verification process is then much simpler.
- * This mode is anticipating support for the Java Specification Request 202.
- * Note that JSR inlining is optional only for target platform lesser than 1.5. From 1.5 on, the JSR
- * inlining is mandatory (also see related setting "org.eclipse.jdt.core.compiler.codegen.targetPlatform").
- * - option id: "org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Javadoc Comment Support
- * When this support is disabled, the compiler will ignore all javadoc problems options settings
- * and will not report any javadoc problem. It will also not find any reference in javadoc comment and
- * DOM AST Javadoc node will be only a flat text instead of having structured tag elements.
- * - option id: "org.eclipse.jdt.core.compiler.doc.comment.support"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Reporting Attempt to Override Package Visible Method
- * A package visible method, which is any method that is not explicitly
- * declared as public, protected or private, is not visible from other
- * packages, and thus cannot be overridden from another package.
- * Attempting to override a package visible method from another package
- * introduces a new method that is unrelated to the original one. When
- * enabling this option, the compiler will signal such situations as an
- * error or a warning.
- * - option id: "org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Method With Constructor Name
- * Naming a method with a constructor name is generally considered poor
- * style programming. When enabling this option, the compiler will signal such
- * scenarii either as an error or a warning.
- * - option id: "org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Deprecation
- * When enabled, the compiler will signal use of deprecated API either as an
- * error or a warning.
- * - option id: "org.eclipse.jdt.core.compiler.problem.deprecation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Deprecation Inside Deprecated Code
- * When enabled, the compiler will signal use of deprecated API inside deprecated code.
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.deprecation".
- * - option id: "org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Deprecation In Non Deprecated Code
- * When enabled, the compiler will signal use of deprecated API in non
- * deprecated code.
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.deprecation".
- * - option id: "org.eclipse.jdt.core.compiler.problem.deprecationInNonDeprecatedCode"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Reporting Deprecation When Overriding Deprecated Method
- * When enabled, the compiler will signal the declaration of a method overriding a deprecated one.
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.deprecation".
- * - option id: "org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Hidden Catch Block
- * Locally to a try statement, some catch blocks may hide others . For example,
- * try { throw new java.io.CharConversionException();
- * } catch (java.io.CharConversionException e) {
- * } catch (java.io.IOException e) {}.
- * When enabling this option, the compiler will issue an error or a warning for hidden
- * catch blocks corresponding to checked exceptions
- * - option id: "org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Unused Local
- * When enabled, the compiler will issue an error or a warning for unused local
- * variables (that is, variables never read from)
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedLocal"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Unused Parameter
- * When enabled, the compiler will issue an error or a warning for unused method
- * parameters (that is, parameters never read from)
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameter"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Unused Parameter if Implementing Abstract Method
- * When enabled, the compiler will signal unused parameters in abstract method implementations.
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedParameter".
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Unused Parameter if Overriding Concrete Method
- * When enabled, the compiler will signal unused parameters in methods overriding concrete ones.
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedParameter".
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Consider Reference in Doc Comment for Unused Parameter Check
- * When enabled, the compiler will consider doc comment references to parameters (i.e. @param clauses) for the unused
- * parameter check. Thus, documented parameters will be considered as mandated as per doc contract.
- * The severity of the unused parameter problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedParameter".
- * Note: this option has no effect until the doc comment support is enabled according to the
- * option "org.eclipse.jdt.core.compiler.doc.comment.support".
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Reporting Unused Import
- * When enabled, the compiler will issue an error or a warning for unused import
- * reference
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedImport"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Unused Private Members
- * When enabled, the compiler will issue an error or a warning whenever a private
- * method or field is declared but never used within the same unit.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Assignment with no Effect
- * When enabled, the compiler will issue an error or a warning whenever an assignment
- * has no effect (e.g 'x = x').
- * - option id: "org.eclipse.jdt.core.compiler.problem.noEffectAssignment"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Empty Statements and Unnecessary Semicolons
- * When enabled, the compiler will issue an error or a warning if an empty statement or a
- * unnecessary semicolon is encountered.
- * - option id: "org.eclipse.jdt.core.compiler.problem.emptyStatement"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Unnecessary Type Check
- * When enabled, the compiler will issue an error or a warning when a cast or an instanceof operation
- * is unnecessary.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Unnecessary Else
- * When enabled, the compiler will issue an error or a warning when a statement is unnecessarily
- * nested within an else clause (in situation where then clause is not completing normally).
- * - option id: "org.eclipse.jdt.core.compiler.problem.unnecessaryElse"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Synthetic Access Emulation
- * When enabled, the compiler will issue an error or a warning whenever it emulates
- * access to a non-accessible member of an enclosing type. Such access can have
- * performance implications.
- * - option id: "org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Non-Externalized String Literal
- * When enabled, the compiler will issue an error or a warning for non externalized
- * String literal (that is, not tagged with //$NON-NLS-<n>$).
- * - option id: "org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Usage of 'assert' Identifier
- * When enabled, the compiler will issue an error or a warning whenever 'assert' is
- * used as an identifier (reserved keyword in 1.4)
- * - option id: "org.eclipse.jdt.core.compiler.problem.assertIdentifier"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Usage of 'enum' Identifier
- * When enabled, the compiler will issue an error or a warning whenever 'enum' is
- * used as an identifier (reserved keyword in 1.5)
- * - option id: "org.eclipse.jdt.core.compiler.problem.enumIdentifier"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Non-Static Reference to a Static Member
- * When enabled, the compiler will issue an error or a warning whenever a static field
- * or method is accessed with an expression receiver. A reference to a static member should
- * be qualified with a type name.
- * - option id: "org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Indirect Reference to a Static Member
- * When enabled, the compiler will issue an error or a warning whenever a static field
- * or method is accessed in an indirect way. A reference to a static member should
- * preferably be qualified with its declaring type name.
- * - option id: "org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Interface Method not Compatible with non-Inherited Methods
- * When enabled, the compiler will issue an error or a warning whenever an interface
- * defines a method incompatible with a non-inherited Object method. Until this conflict
- * is resolved, such an interface cannot be implemented, For example,
- * interface I {
- * int clone();
- * }
- * - option id: "org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Usage of char[] Expressions in String Concatenations
- * When enabled, the compiler will issue an error or a warning whenever a char[] expression
- * is used in String concatenations (for example, "hello" + new char[]{'w','o','r','l','d'}).
- * - option id: "org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Local Variable Declaration Hiding another Variable
- * When enabled, the compiler will issue an error or a warning whenever a local variable
- * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).
- * - option id: "org.eclipse.jdt.core.compiler.problem.localVariableHiding"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Field Declaration Hiding another Variable
- * When enabled, the compiler will issue an error or a warning whenever a field
- * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).
- * - option id: "org.eclipse.jdt.core.compiler.problem.fieldHiding"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Special Parameter Hiding another Field
- * When enabled, the compiler will signal cases where a constructor or setter method parameter declaration
- * is hiding some field (either locally, inherited or defined in enclosing type).
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.localVariableHiding".
- * - option id: "org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Type Declaration Hiding another Type
- * When enabled, the compiler will issue an error or a warning in situations where a type parameter
- * declaration is hiding some type, when a nested type is hiding some type parameter, or when
- * a nested type is hiding another nested type defined in same unit.
- * - option id: "org.eclipse.jdt.core.compiler.problem.typeParameterHiding"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Possible Accidental Boolean Assignment
- * When enabled, the compiler will issue an error or a warning if a boolean assignment is acting as the condition
- * of a control statement (where it probably was meant to be a boolean comparison).
- * - option id: "org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Undocumented Empty Block
- * When enabled, the compiler will issue an error or a warning when an empty block is detected and it is not
- * documented with any comment.
- * - option id: "org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Finally Blocks Not Completing Normally
- * When enabled, the compiler will issue an error or a warning when a finally block does not complete normally.
- * - option id: "org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Unused Declared Thrown Exception
- * When enabled, the compiler will issue an error or a warning when a
- * method or a constructor is declaring a thrown exception, but never
- * actually raises it in its body. Depending on
- * "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeUncheckedExceptions",
- * only checked exceptions will be considered (default), or all
- * exceptions, including unchecked ones, will be considered.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Unused Declared Thrown Exception in Overriding Method
- * When disabled, the compiler will report unused declared thrown
- * exceptions neither on overriding methods nor on implementing methods.
- *
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException".
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Consider Reference in Doc Comment for Unused Declared Thrown Exception Check
- * When enabled, the compiler will consider doc comment references to exceptions (i.e. @throws clauses) for the unused
- * declared thrown exception check. Thus, documented exceptions will be considered as mandated as per doc contract.
- * The severity of the unused declared thrown exception problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException".
- * Note: this option has no effect until the doc comment support is enabled according to the
- * option "org.eclipse.jdt.core.compiler.doc.comment.support".
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Reporting Unused Declared Thrown Unchecked Exceptions
- * When enabled, the compiler will report unused declared thrown
- * exceptions for all exceptions, including unchecked ones. When
- * disabled, only checked exceptions will be considered.
- *
- * The severity of the problem is controlled with option
- * "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException".
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeUncheckedExceptions"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Unqualified Access to Field
- * When enabled, the compiler will issue an error or a warning when a field is access without any qualification.
- * In order to improve code readability, it should be qualified, e.g. 'x' should rather be written 'this.x'.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Unchecked Type Operation
- * When enabled, the compiler will issue an error or a warning whenever an operation involves generic types, and potentially
- * invalidates type safety since involving raw types (e.g. invoking #foo(X<String>) with arguments (X)).
- * - option id: "org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Raw Type Reference
- * When enabled, the compiler will issue an error or a warning when detecting references to raw types. Raw types are
- * discouraged, and are intended to help interfacing with legacy code. In the future, the language specification may
- * reject raw references to generic types.
- * - option id: "org.eclipse.jdt.core.compiler.problem.rawTypeReference"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting final Bound for Type Parameter
- * When enabled, the compiler will issue an error or a warning whenever a generic type parameter is associated with a
- * bound corresponding to a final type; since final types cannot be further extended, the parameter is pretty useless.
- * - option id: "org.eclipse.jdt.core.compiler.problem.finalParameterBound"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Missing Declaration of serialVersionUID Field on Serializable Class
- * When enabled, the compiler will issue an error or a warning whenever a serializable class is missing a local declaration
- * of a serialVersionUID field. This field must be declared as static final and be of type long.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingSerialVersion"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Varargs Argument Needing a Cast in Method/Constructor Invocation
- * When enabled, the compiler will issue an error or a warning whenever a varargs arguments should be cast
- * when passed to a method/constructor invocation. (e.g. Class.getMethod(String name, Class ... args )
- * invoked with arguments ("foo", null)).
- * - option id: "org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Null Dereference
- * When enabled, the compiler will issue an error or a warning whenever a
- * variable that is statically known to hold a null value is used to
- * access a field or method.
- *
- * - option id: "org.eclipse.jdt.core.compiler.problem.nullReference"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Potential Null Dereference
- * When enabled, the compiler will issue an error or a warning whenever a
- * variable that has formerly been tested against null but is not (no more)
- * statically known to hold a non-null value is used to access a field or
- * method.
- *
- * - option id: "org.eclipse.jdt.core.compiler.problem.potentialNullReference"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Redundant Null Check
- * When enabled, the compiler will issue an error or a warning whenever a
- * variable that is statically known to hold a null or a non-null value
- * is tested against null.
- *
- * - option id: "org.eclipse.jdt.core.compiler.problem.redundantNullCheck"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Use of Annotation Type as Super Interface
- * When enabled, the compiler will issue an error or a warning whenever an annotation type is used
- * as a super-interface. Though legal, this is discouraged.
- * - option id: "org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Missing @Override Annotation
- * When enabled, the compiler will issue an error or a warning whenever encountering a method
- * declaration which overrides a superclass method but has no @Override annotation.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Missing @Deprecated Annotation
- * When enabled, the compiler will issue an error or a warning whenever encountering a declaration
- * carrying a @deprecated doc tag but having no corresponding @Deprecated annotation.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Incomplete Enum Switch
- * When enabled, the compiler will issue an error or a warning whenever
- * an enum constant has no corresponding case label in an enum switch
- * statement.
- * - option id: "org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Boxing/Unboxing Conversion
- * When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing
- * conversion is performed.
- * - option id: "org.eclipse.jdt.core.compiler.problem.autoboxing"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Invalid Javadoc Comment
- * This is the generic control for the severity of Javadoc problems.
- * When enabled, the compiler will issue an error or a warning for a problem in Javadoc.
- * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadoc"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Visibility Level For Invalid Javadoc Tags
- * Set the minimum visibility level for Javadoc tag problems. Below this level problems will be ignored.
- * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"
- * - possible values: { "public", "protected", "default", "private" }
- * - default: "public"
- *
- * COMPILER / Reporting Invalid Javadoc Tags
- * When enabled, the compiler will signal unbound or unexpected reference tags in Javadoc.
- * A 'throws' tag referencing an undeclared exception would be considered as unexpected.
- *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
- * also see the setting "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility".
- *
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.invalidJavadoc".
- * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTags"
- * - possible values: { "disabled", "enabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting missing tag description
- * When enabled, the compiler will report a warning or an error for any Javadoc missing a required description.
- * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.invalidJavadoc".
- * This option is NOT dependent from the Report errors in tags option.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription"
- * - possible values: { "return_tag", "all_tags", "no_tag" }
- * - default: "return_tag"
- *
- * COMPILER / Reporting Invalid Javadoc Tags with Deprecated References
- * Specify whether the compiler will report deprecated references used in Javadoc tags.
- *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
- * also see the setting "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility".
- * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Invalid Javadoc Tags with Not Visible References
- * Specify whether the compiler will report non-visible references used in Javadoc tags.
- *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
- * also see the setting "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility".
- * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Missing Javadoc Tags
- * This is the generic control for the severity of Javadoc missing tag problems.
- * When enabled, the compiler will issue an error or a warning when tags are missing in Javadoc comments.
- *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
- * also see the setting "org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility".
- *
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTags"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Visibility Level For Missing Javadoc Tags
- * Set the minimum visibility level for Javadoc missing tag problems. Below this level problems will be ignored.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"
- * - possible values: { "public", "protected", "default", "private" }
- * - default: "public"
- *
- * COMPILER / Reporting Missing Javadoc Tags on Overriding Methods
- * Specify whether the compiler will verify overriding methods in order to report Javadoc missing tag problems.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Reporting Missing Javadoc Comments
- * This is the generic control for the severity of missing Javadoc comment problems.
- * When enabled, the compiler will issue an error or a warning when Javadoc comments are missing.
- *
Note that this diagnosis can be enabled based on the visibility of the construct associated with the expected Javadoc;
- * also see the setting "org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility".
- *
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocComments"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Visibility Level For Missing Javadoc Comments
- * Set the minimum visibility level for missing Javadoc problems. Below this level problems will be ignored.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"
- * - possible values: { "public", "protected", "default", "private" }
- * - default: "public"
- *
- * COMPILER / Reporting Missing Javadoc Comments on Overriding Methods
- * Specify whether the compiler will verify overriding methods in order to report missing Javadoc comment problems.
- * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * COMPILER / Maximum Number of Problems Reported per Compilation Unit
- * Specify the maximum number of problems reported on each compilation unit.
- * - option id: "org.eclipse.jdt.core.compiler.maxProblemPerUnit"
- * - possible values: "<n>" where <n> is zero or a positive integer (if zero then all problems are reported).
- * - default: "100"
- *
- * COMPILER / Treating Optional Error as Fatal
- * When enabled, optional errors (i.e. optional problems which severity is set to "error") will be treated as standard
- * compiler errors, yielding problem methods/types preventing from running offending code until the issue got resolved.
- * When disabled, optional errors are only considered as warnings, still carrying an error indication to make them more
- * severe. Note that by default, errors are fatal, whether they are optional or not.
- * - option id: "org.eclipse.jdt.core.compiler.problem.fatalOptionalError"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Defining the Automatic Task Tags
- * When the tag list is not empty, the compiler will issue a task marker whenever it encounters
- * one of the corresponding tags inside any comment in Java source code.
- * Generated task messages will start with the tag, and range until the next line separator,
- * comment ending, or tag.
- * When a given line of code bears multiple tags, each tag will be reported separately.
- * Moreover, a tag immediately followed by another tag will be reported using the contents of the
- * next non-empty tag of the line, if any.
- * Note that tasks messages are trimmed. If a tag is starting with a letter or digit, then it cannot be leaded by
- * another letter or digit to be recognized ("fooToDo" will not be recognized as a task for tag "ToDo", but "foo#ToDo"
- * will be detected for either tag "ToDo" or "#ToDo"). Respectively, a tag ending with a letter or digit cannot be followed
- * by a letter or digit to be recognized ("ToDofoo" will not be recognized as a task for tag "ToDo", but "ToDo:foo" will
- * be detected either for tag "ToDo" or "ToDo:").
- * - option id: "org.eclipse.jdt.core.compiler.taskTags"
- * - possible values: { "<tag>[,<tag>]*" } where <tag> is a String without any wild-card or leading/trailing spaces
- * - default: "TODO,FIXME,XXX"
- *
- * COMPILER / Defining the Automatic Task Priorities
- * In parallel with the Automatic Task Tags, this list defines the priorities (high, normal or low)
- * of the task markers issued by the compiler.
- * If the default is specified, the priority of each task marker is "NORMAL".
- * - option id: "org.eclipse.jdt.core.compiler.taskPriorities"
- * - possible values: { "<priority>[,<priority>]*" } where <priority> is one of "HIGH", "NORMAL" or "LOW"
- * - default: "NORMAL,HIGH,NORMAL"
- *
- * COMPILER / Determining whether task tags are case-sensitive
- * When enabled, task tags are considered in a case-sensitive way.
- * - option id: "org.eclipse.jdt.core.compiler.taskCaseSensitive"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Reporting Forbidden Reference to Type with Restricted Access
- * When enabled, the compiler will issue an error or a warning when referring to a type that is non accessible, as defined according
- * to the access rule specifications.
- * - option id: "org.eclipse.jdt.core.compiler.problem.forbiddenReference"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Discouraged Reference to Type with Restricted Access
- * When enabled, the compiler will issue an error or a warning when referring to a type with discouraged access, as defined according
- * to the access rule specifications.
- * - option id: "org.eclipse.jdt.core.compiler.problem.discouragedReference"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Determining Effect of @SuppressWarnings
- * When enabled, the @SuppressWarnings annotation can be used to suppress some compiler warnings.
- * When disabled, all @SupressWarnings annotations are ignored; i.e., warnings are reported.
- * - option id: "org.eclipse.jdt.core.compiler.problem.suppressWarnings"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * COMPILER / Reporting Unhandled Warning Token for @SuppressWarnings
- * When enabled, the compiler will issue an error or a warning when encountering a token
- * it cannot handle inside a @SuppressWarnings annotation.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Unnecessary @SuppressWarnings
- * When enabled, the compiler will issue an error or a warning when encountering @SuppressWarnings annotation
- * for which no corresponding warning got detected in the code. This diagnostic is provided to help developers to get
- * rid of transient @SuppressWarnings no longer needed. Note that @SuppressWarnings("all") is still
- * silencing the warning for unnecessary @SuppressWarnings, as it is the master switch to silence ALL warnings.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedWarningToken"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Unreferenced Label
- * When enabled, the compiler will issue an error or a warning when encountering a labeled statement which label
- * is never explicitly referenced. A label is considered to be referenced if its name explicitly appears behind a break
- * or continue statement; for instance the following label would be considered unreferenced; LABEL: { break; }
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedLabel"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Parameter Assignment
- * When enabled, the compiler will issue an error or a warning if a parameter is
- * assigned to.
- * - option id: "org.eclipse.jdt.core.compiler.problem.parameterAssignment"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Switch Fall-Through Case
- * When enabled, the compiler will issue an error or a warning if a case may be
- * entered by falling through previous case. Empty cases are allowed.
- * - option id: "org.eclipse.jdt.core.compiler.problem.fallthroughCase"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Overriding method that doesn't call the super method invocation
- * When enabled, the compiler will issue an error or a warning if a method is overriding a method without calling
- * the super invocation.
- * - option id: "org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * COMPILER / Reporting Presence of Type Arguments for a Non-Generic Method Invocation
- * When enabled, the compiler will issue an error or a warning whenever type arguments are encountered for a
- * non-generic method invocation. Note that prior to compliance level is "1.7", this situation would automatically result
- * in an error. From Java7 on, unused type arguments are being tolerated, and optionally warned against.
- * - option id: "org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "warning"
- *
- * COMPILER / Reporting Redundant Superinterface
- * When enabled, the compiler will issue an error or a warning if a type
- * explicitly implements an interface that is already implemented by any
- * of its supertypes.
- * - option id: "org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * BUILDER / Specifying Filters for Resource Copying Control
- * Allow to specify some filters to control the resource copy process.
- * - option id: "org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"
- * - possible values: { "<name>[,<name>]* } where <name> is a file name pattern (* and ? wild-cards allowed)
- * or the name of a folder which ends with '/'
- * - default: ""
- *
- * BUILDER / Abort if Invalid Classpath
- * Allow to toggle the builder to abort if the classpath is invalid
- * - option id: "org.eclipse.jdt.core.builder.invalidClasspath"
- * - possible values: { "abort", "ignore" }
- * - default: "abort"
- *
- * BUILDER / Cleaning Output Folder(s)
- * Indicate whether the JavaBuilder is allowed to clean the output folders
- * when performing full build operations.
- * - option id: "org.eclipse.jdt.core.builder.cleanOutputFolder"
- * - possible values: { "clean", "ignore" }
- * - default: "clean"
- *
- * BUILDER / Recreate Modified class files in Output Folder
- * Indicate whether the JavaBuilder should check for any changes to .class files
- * in the output folders while performing incremental build operations. If changes
- * are detected to managed .class files, then a full build is performed, otherwise
- * the changes are left as is. Tools further altering generated .class files, like optimizers,
- * should ensure this option remains set in its default state of ignore.
- * - option id: "org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"
- * - possible values: { "enabled", "ignore" }
- * - default: "ignore"
- *
- * BUILDER / Reporting Duplicate Resources
- * Indicate the severity of the problem reported when more than one occurrence
- * of a resource is to be copied into the output location.
- * - option id: "org.eclipse.jdt.core.builder.duplicateResourceTask"
- * - possible values: { "error", "warning" }
- * - default: "warning"
- *
- * JAVACORE / Computing Project Build Order
- * Indicate whether JavaCore should enforce the project build order to be based on
- * the classpath prerequisite chain. When requesting to compute, this takes over
- * the platform default order (based on project references).
- * - option id: "org.eclipse.jdt.core.computeJavaBuildOrder"
- * - possible values: { "compute", "ignore" }
- * - default: "ignore"
- *
- * JAVACORE / Default Source Encoding Format
- * Get the default encoding format of source files. This value is
- * immutable and preset to the result of ResourcesPlugin.getEncoding().
- * It is offered as a convenience shortcut only.
- * - option id: "org.eclipse.jdt.core.encoding"
- * - value: <immutable, platform default value>
- *
- * JAVACORE / Reporting Incomplete Classpath
- * Indicate the severity of the problem reported when an entry on the classpath does not exist,
- * is not legite or is not visible (for example, a referenced project is closed).
- * - option id: "org.eclipse.jdt.core.incompleteClasspath"
- * - possible values: { "error", "warning"}
- * - default: "error"
- *
- * JAVACORE / Reporting Classpath Cycle
- * Indicate the severity of the problem reported when a project is involved in a cycle.
- * - option id: "org.eclipse.jdt.core.circularClasspath"
- * - possible values: { "error", "warning" }
- * - default: "error"
- *
- * JAVACORE / Reporting Incompatible JDK Level for Required Binaries
- * Indicate the severity of the problem reported when a project prerequisites another project
- * or library with an incompatible target JDK level (e.g. project targeting 1.1 vm, but compiled against 1.4 libraries).
- * - option id: "org.eclipse.jdt.core.incompatibleJDKLevel"
- * - possible values: { "error", "warning", "ignore" }
- * - default: "ignore"
- *
- * JAVACORE / Enabling Usage of Classpath Exclusion Patterns
- * When disabled, no entry on a project classpath can be associated with
- * an exclusion pattern.
- * - option id: "org.eclipse.jdt.core.classpath.exclusionPatterns"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * JAVACORE / Enabling Usage of Classpath Multiple Output Locations
- * When disabled, no entry on a project classpath can be associated with
- * a specific output location, preventing thus usage of multiple output locations.
- * - option id: "org.eclipse.jdt.core.classpath.multipleOutputLocations"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * JAVACORE / Set the timeout value for retrieving the method's parameter names from javadoc
- * Timeout in milliseconds to retrieve the method's parameter names from javadoc.
- * If the value is 0, the parameter names are not fetched and the raw names are returned.
- * - option id: "org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc"
- * - possible values: "<n>", where n is an integer greater than or equal to 0
- * - default: "50"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: FORMATTER / Inserting New Line Before Opening Brace
- * When Insert, a new line is inserted before an opening brace, otherwise nothing
- * is inserted
- * - option id: "org.eclipse.jdt.core.formatter.newline.openingBrace"
- * - possible values: { "insert", "do not insert" }
- * - default: "do not insert"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: FORMATTER / Inserting New Line Inside Control Statement
- * When Insert, a new line is inserted between } and following else, catch, finally
- * - option id: "org.eclipse.jdt.core.formatter.newline.controlStatement"
- * - possible values: { "insert", "do not insert" }
- * - default: "do not insert"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Clearing Blank Lines
- * When Clear all, all blank lines are removed. When Preserve one, only one is kept
- * and all others removed.
- * - option id: "org.eclipse.jdt.core.formatter.newline.clearAll"
- * - possible values: { "clear all", "preserve one" }
- * - default: "preserve one"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Inserting New Line Between Else/If
- * When Insert, a blank line is inserted between an else and an if when they are
- * contiguous. When choosing to not insert, else-if will be kept on the same
- * line when possible.
- * - option id: "org.eclipse.jdt.core.formatter.newline.elseIf"
- * - possible values: { "insert", "do not insert" }
- * - default: "do not insert"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Inserting New Line In Empty Block
- * When insert, a line break is inserted between contiguous { and }, if } is not followed
- * by a keyword.
- * - option id: "org.eclipse.jdt.core.formatter.newline.emptyBlock"
- * - possible values: { "insert", "do not insert" }
- * - default: "insert"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Splitting Lines Exceeding Length
- * Enable splitting of long lines (exceeding the configurable length). Length of 0 will
- * disable line splitting
- * - option id: "org.eclipse.jdt.core.formatter.lineSplit"
- * - possible values: "<n>", where n is zero or a positive integer
- * - default: "80"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Compacting Assignment
- * Assignments can be formatted asymmetrically, for example 'int x= 2;', when Normal, a space
- * is inserted before the assignment operator
- * - option id: "org.eclipse.jdt.core.formatter.style.assignment"
- * - possible values: { "compact", "normal" }
- * - default: "normal"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Defining Indentation Character
- * Either choose to indent with tab characters or spaces
- * - option id: "org.eclipse.jdt.core.formatter.tabulation.char"
- * - possible values: { "tab", "space" }
- * - default: "tab"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Defining Space Indentation Length
- * When using spaces, set the amount of space characters to use for each
- * indentation mark.
- * - option id: "org.eclipse.jdt.core.formatter.tabulation.size"
- * - possible values: "<n>", where n is a positive integer
- * - default: "4"
- *
- * DEPRECATED SEE DefaultCodeFormatterOptions: Inserting space in cast expression
- * When Insert, a space is added between the type and the expression in a cast expression.
- * - option id: "org.eclipse.jdt.core.formatter.space.castexpression"
- * - possible values: { "insert", "do not insert" }
- * - default: "insert"
- *
- * CODEASSIST / Activate Visibility Sensitive Completion
- * When active, completion doesn't show that you can not see
- * (for example, you can not see private methods of a super class).
- * - option id: "org.eclipse.jdt.core.codeComplete.visibilityCheck"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * CODEASSIST / Activate Deprecation Sensitive Completion
- * When enabled, completion doesn't propose deprecated members and types.
- * - option id: "org.eclipse.jdt.core.codeComplete.deprecationCheck"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * CODEASSIST / Automatic Qualification of Implicit Members
- * When active, completion automatically qualifies completion on implicit
- * field references and message expressions.
- * - option id: "org.eclipse.jdt.core.codeComplete.forceImplicitQualification"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * CODEASSIST / Define the Prefixes for Field Name
- * When the prefixes is non empty, completion for field name will begin with
- * one of the proposed prefixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.fieldPrefixes"
- * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Prefixes for Static Field Name
- * When the prefixes is non empty, completion for static field name will begin with
- * one of the proposed prefixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"
- * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Prefixes for Local Variable Name
- * When the prefixes is non empty, completion for local variable name will begin with
- * one of the proposed prefixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.localPrefixes"
- * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Prefixes for Argument Name
- * When the prefixes is non empty, completion for argument name will begin with
- * one of the proposed prefixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.argumentPrefixes"
- * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Suffixes for Field Name
- * When the suffixes is non empty, completion for field name will end with
- * one of the proposed suffixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.fieldSuffixes"
- * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Suffixes for Static Field Name
- * When the suffixes is non empty, completion for static field name will end with
- * one of the proposed suffixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"
- * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Suffixes for Local Variable Name
- * When the suffixes is non empty, completion for local variable name will end with
- * one of the proposed suffixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.localSuffixes"
- * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Define the Suffixes for Argument Name
- * When the suffixes is non empty, completion for argument name will end with
- * one of the proposed suffixes.
- * - option id: "org.eclipse.jdt.core.codeComplete.argumentSuffixes"
- * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
- * - default: ""
- *
- * CODEASSIST / Activate Forbidden Reference Sensitive Completion
- * When enabled, completion doesn't propose elements which match a
- * forbidden reference rule.
- * - option id: "org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * CODEASSIST / Activate Discouraged Reference Sensitive Completion
- * When enabled, completion doesn't propose elements which match a
- * discouraged reference rule.
- * - option id: "org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck"
- * - possible values: { "enabled", "disabled" }
- * - default: "disabled"
- *
- * CODEASSIST / Activate Camel Case Sensitive Completion
- * When enabled, completion shows proposals whose name match the CamelCase
- * pattern.
- * - option id: "org.eclipse.jdt.core.codeComplete.camelCaseMatch"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
- * CODEASSIST / Activate Suggestion of Static Import
- * When enabled, completion proposals can contain static import
- * pattern.
- * - option id: "org.eclipse.jdt.core.codeComplete.suggestStaticImports"
- * - possible values: { "enabled", "disabled" }
- * - default: "enabled"
- *
+ * + * Helper constants have been defined on JavaCore for each of the option IDs + * (categorized in Code assist option ID, Compiler option ID and Core option ID) + * and some of their acceptable values (categorized in Option value). Some + * options accept open value sets beyond the documented constant values. + *
+ * Note: each release may add new options.
+ *
+ * @return a table of all known configurable options with their default values
*/
public static Hashtable getDefaultOptions(){
return JavaModelManager.getJavaModelManager().getDefaultOptions();
@@ -3176,8 +3094,12 @@
* Helper method for returning one option value only. Equivalent to (String)JavaCore.getOptions().get(optionName)
* Note that it may answer null if this option does not exist.
*
- * For a complete description of the configurable options, see getDefaultOptions.
- *
+ * Note: each release may add new options. * * @param optionName the name of an option * @return the String value of a given option @@ -3192,7 +3114,13 @@ /** * Returns the table of the current options. Initially, all options have their default values, * and this method returns a table that includes all known options. - *
For a complete description of the configurable options, see getDefaultOptions.
+ * Helper constants have been defined on JavaCore for each of the option IDs + * (categorized in Code assist option ID, Compiler option ID and Core option ID) + * and some of their acceptable values (categorized in Option value). Some + * options accept open value sets beyond the documented constant values. + *
+ * Note: each release may add new options. *
Returns a default set of options even if the platform is not running.
* * @return table of current settings of all options @@ -4817,8 +4745,8 @@ * Sets the default's compiler options inside the given options map according * to the given compliance. * - *The given compliance must be one of the compliance supported by the compiler. - * See {@link #getDefaultOptions()} for a list of compliance values.
+ *The given compliance must be one of those supported by the compiler, + * that is one of the acceptable values for option {@link #COMPILER_COMPLIANCE}. * *
The list of modified options is:
*
- * For a complete description of the configurable options, see
- * getDefaultOptions.
- *
+ * Note: each release may add new options.
*
* @param newOptions
* the new options (key type: String; value type:
@@ -4926,4 +4857,4 @@
super.start(context);
JavaModelManager.getJavaModelManager().startup();
}
-}
\ No newline at end of file
+}