Attachment 88294 Details for Bug 202490 – Fix + test case

[patch] Fix + test case

patch.txt (text/plain), 189.41 KB, created by Maxime Daniel

on 2008-01-30 11:06:27 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Maxime Daniel

Created: 2008-01-30 11:06:27 EST

Size: 189.41 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core.tests.model
>Index: src/org/eclipse/jdt/core/tests/dom/RunAllTests.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/RunAllTests.java,v
>retrieving revision 1.26
>diff -u -r1.26 RunAllTests.java
>--- src/org/eclipse/jdt/core/tests/dom/RunAllTests.java	29 Mar 2006 04:03:06 -0000	1.26
>+++ src/org/eclipse/jdt/core/tests/dom/RunAllTests.java	30 Jan 2008 15:56:23 -0000
>@@ -35,6 +35,7 @@
> 		org.eclipse.jdt.core.tests.rewrite.describing.ASTRewritingTest.class,
> 		org.eclipse.jdt.core.tests.rewrite.modifying.ASTRewritingModifyingTest.class,
> 		org.eclipse.jdt.core.tests.dom.ASTPositionsTest.class,
>+		org.eclipse.jdt.core.tests.dom.APIDocumentationTests.class,
> 	};
> }
> public static Test suite() {
>Index: src/org/eclipse/jdt/core/tests/dom/APIDocumentationTests.java
>===================================================================
>RCS file: src/org/eclipse/jdt/core/tests/dom/APIDocumentationTests.java
>diff -N src/org/eclipse/jdt/core/tests/dom/APIDocumentationTests.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jdt/core/tests/dom/APIDocumentationTests.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,235 @@
>+/*******************************************************************************
>+ * Copyright (c) 2008 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ * IBM Corporation - initial API and implementation
>+ *******************************************************************************/
>+package org.eclipse.jdt.core.tests.dom;
>+
>+import java.io.BufferedReader;
>+import java.io.File;
>+import java.io.IOException;
>+import java.io.StringReader;
>+import java.lang.reflect.Field;
>+import java.lang.reflect.Modifier;
>+import java.util.Hashtable;
>+import java.util.Iterator;
>+import java.util.Map;
>+
>+import junit.framework.Test;
>+
>+import org.eclipse.core.runtime.CoreException;
>+import org.eclipse.core.runtime.FileLocator;
>+import org.eclipse.jdt.core.JavaCore;
>+import org.eclipse.jdt.core.dom.AST;
>+import org.eclipse.jdt.core.dom.ASTNode;
>+import org.eclipse.jdt.core.dom.ASTParser;
>+import org.eclipse.jdt.core.dom.ASTVisitor;
>+import org.eclipse.jdt.core.dom.FieldDeclaration;
>+import org.eclipse.jdt.core.dom.Javadoc;
>+import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
>+
>+/**
>+ * The intent of this tests series is to check the consistency of parts of our
>+ * APIs documentation with real values and results.
>+ */
>+public class APIDocumentationTests extends AbstractASTTests {
>+	public APIDocumentationTests(String name) {
>+		super(name);
>+	}
>+
>+	public static Test suite() {
>+		return buildModelTestSuite(APIDocumentationTests.class);
>+	}
>+	
>+	// Use this static initializer to specify subset for tests
>+	// All specified tests which do not belong to the class are skipped...
>+	static {
>+//		TESTS_PREFIX = "testBug86380";
>+//		TESTS_NAMES = new String[] { "test056" };
>+//		TESTS_NUMBERS = new int[] { 78, 79, 80 };
>+//		TESTS_RANGE = new int[] { 83304, -1 };
>+		}
>+
>+/**
>+ * Helper class able to analyze JavaCore options javadocs.
>+ */
>+class JavaCoreJavadocAnalyzer {
>+	private String javadoc;
>+	void reset(String newJavadoc) {
>+		// do not pass null - unchecked
>+		this.javadoc = newJavadoc;
>+		this.analyzed = false;
>+		this.optionID = null;
>+		this.defaultValue = null;
>+	}
>+	private boolean analyzed;
>+	private String optionID, defaultValue;
>+	private void analyze() {
>+		if (!this.analyzed) {
>+			this.analyzed = true;
>+			BufferedReader javadocReader = new BufferedReader(new StringReader(this.javadoc));
>+			String line;
>+			try {
>+				while ((line = javadocReader.readLine()) != null) {
>+					if (line.startsWith(" * <dt>Option id:")) {
>+						this.optionID = line.substring(33, line.length() - 13);
>+					} else if (line.startsWith(" * <dt>Default:")) {
>+						this.defaultValue = line.substring(31, line.length() - 13);
>+						return;
>+					} 
>+				}
>+			} catch (IOException e) {
>+				// silent
>+			}
>+		}
>+	}
>+	String getOptionID() {
>+		analyze();
>+		return this.optionID;
>+	}
>+	String getDefaultValue() {
>+		analyze();
>+		return this.defaultValue;
>+	}
>+	boolean isDeprecated() {
>+		return this.javadoc.indexOf("* @deprecated") != -1;
>+	}
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202490
>+// checks that option ids and option default values match between the code and
>+// the javadoc
>+public void test001() throws CoreException, IllegalArgumentException, IllegalAccessException, IOException {
>+	// fetch JavaCore class
>+	Class javaCoreClass = JavaCore.class;
>+	// fetch JavaCore source file
>+	File javaCoreSourceFile = new File(FileLocator.toFileURL(JavaCore.getJavaCore().getBundle().getEntry("/model/org/eclipse/jdt/core/JavaCore.java")).getPath());
>+	if (javaCoreSourceFile.exists()) {
>+		// load field values in a map
>+		Hashtable realOptionIDs = new Hashtable();
>+		Field[] fields = javaCoreClass.getDeclaredFields();
>+		for (int i = 0, l = fields.length; i < l; i++) {
>+			Field field = fields[i];
>+			int modifiers = field.getModifiers();
>+			if (Modifier.isPublic(modifiers) &&
>+					Modifier.isStatic(modifiers) &&
>+					field.getType() == String.class) {
>+				String constantValue = (String) field.get(null);
>+				if (constantValue.startsWith(JavaCore.PLUGIN_ID)) {
>+					realOptionIDs.put(field.getName(), constantValue);
>+				}
>+			}
>+		}
>+		// exempt a few values
>+		realOptionIDs.remove("PLUGIN_ID");
>+		realOptionIDs.remove("BUILDER_ID");
>+		realOptionIDs.remove("JAVA_SOURCE_CONTENT_TYPE");
>+		realOptionIDs.remove("MODEL_ID");
>+		realOptionIDs.remove("NATURE_ID");
>+		// build cross-index
>+		Hashtable realOptionNames = new Hashtable();
>+		Iterator optionIDs = realOptionIDs.entrySet().iterator();
>+		while (optionIDs.hasNext()) {
>+			Map.Entry optionID = (Map.Entry) optionIDs.next();
>+			realOptionNames.put(optionID.getValue(), optionID.getKey());
>+		}
>+				
>+		// fetch default option values
>+		Hashtable realDefaultValues = JavaCore.getDefaultOptions();
>+		// load documented values in a map
>+		ASTParser parser = ASTParser.newParser(AST.JLS3);
>+		parser.setSource(org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(javaCoreSourceFile, null));
>+		ASTNode rootNode = parser.createAST(null);
>+		final JavaCoreJavadocAnalyzer analyzer = new JavaCoreJavadocAnalyzer();
>+		final Hashtable javadocOptionIDs = new Hashtable();
>+		final Hashtable javadocDefaultValues = new Hashtable();
>+		final Hashtable deprecatedFields = new Hashtable();
>+		rootNode.accept(new ASTVisitor() {
>+			public boolean visit(FieldDeclaration node) {
>+				String key = ((VariableDeclarationFragment) node.fragments().get(0)).getName().getIdentifier();
>+				Javadoc javadoc = node.getJavadoc();
>+				if (javadoc != null) {
>+					analyzer.reset(javadoc.toString());
>+					String id, value;
>+					if ((id = analyzer.getOptionID()) != null) {
>+						javadocOptionIDs.put(key, id);
>+					}
>+					if ((value = analyzer.getDefaultValue()) != null) {
>+						javadocDefaultValues.put(id, value);
>+					}
>+					if (analyzer.isDeprecated()) {
>+						deprecatedFields.put(key, key /* not null */);
>+					}
>+				}
>+				return super.visit(node);
>+			}
>+		});
>+		// checking ids
>+		Iterator check = realOptionIDs.entrySet().iterator();
>+		String key, value;
>+		String expected = "", actual = "";
>+		while (check.hasNext()) {
>+			Map.Entry entry = (Map.Entry) check.next();
>+			key = (String) entry.getKey();
>+			value = (String) entry.getValue();
>+			if (deprecatedFields.get(key) == null) {
>+				if (!value.equals(javadocOptionIDs.get(key))) {
>+					expected = value;
>+					actual = (String) javadocOptionIDs.get(key);
>+					System.out.println("option ID mismatch for " + key + ", real: " + expected +
>+						", javadoc: " + actual);
>+				}
>+			}
>+		}
>+		check = javadocOptionIDs.entrySet().iterator();
>+		while (check.hasNext()) {
>+			Map.Entry entry = (Map.Entry) check.next();
>+			key = (String) entry.getKey();
>+			value = (String) entry.getValue();
>+			if (!value.equals(realOptionIDs.get(key))) {
>+				expected = value;
>+				actual = (String) realOptionIDs.get(key);
>+				System.out.println("option ID mismatch, javadoc " + expected +
>+					", real " + actual);
>+			}
>+		}
>+		// checking default values
>+		check = realDefaultValues.entrySet().iterator();
>+		while (check.hasNext()) {
>+			Map.Entry entry = (Map.Entry) check.next();
>+			key = (String) entry.getKey();
>+			value = (String) entry.getValue();
>+			String name = (String) realOptionNames.get(key);
>+			if (name != null && deprecatedFields.get(name) == null) {
>+				if (!value.equals(javadocDefaultValues.get(key)) &&
>+						!"org.eclipse.jdt.core.encoding".equals(key)) {
>+					expected = value;
>+					actual = (String) javadocDefaultValues.get(key);
>+					System.out.println("default value mismatch for " + key + ", real: " + expected +
>+						", javadoc: " + actual);
>+				}
>+			}
>+		}
>+		check = javadocDefaultValues.entrySet().iterator();
>+		while (check.hasNext()) {
>+			Map.Entry entry = (Map.Entry) check.next();
>+			key = (String) entry.getKey();
>+			value = (String) entry.getValue();
>+			if (!value.equals(realDefaultValues.get(key)) &&
>+					!"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException".equals(key)) { // will remove once bug 216571 is fixed
>+				expected = value;
>+				actual = (String) realDefaultValues.get(key);
>+				System.out.println("default value mismatch for " + key + ", javadoc " + expected +
>+					", real " + actual);
>+			}
>+		}
>+		assertEquals("One or many discrepancies, including: ", expected, actual);
>+	} else {
>+		System.err.println("JavaCore.java not found, skipping APIDocumentationTests#test001");
>+	}
>+}
>+}
>#P org.eclipse.jdt.core
>Index: model/org/eclipse/jdt/core/JavaCore.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java,v
>retrieving revision 1.598
>diff -u -r1.598 JavaCore.java
>--- model/org/eclipse/jdt/core/JavaCore.java	24 Jan 2008 09:54:33 -0000	1.598
>+++ model/org/eclipse/jdt/core/JavaCore.java	30 Jan 2008 15:56:29 -0000
>@@ -194,1047 +194,1940 @@
> 	 */
> 	public static final String USER_LIBRARY_CONTAINER_ID= "org.eclipse.jdt.USER_LIBRARY"; //$NON-NLS-1$
> 
>-	// *************** Possible IDs for configurable options. ********************
>+	// Begin configurable option IDs {
> 
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+	 * Compiler option ID: 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).
>+	 * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.debug.localVariable"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"generate"</code></dd>
>+	 * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_LOCAL_VARIABLE_ATTR = PLUGIN_ID + ".compiler.debug.localVariable"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+	 * Compiler option ID: Generating Line Number Debug Attribute.
>+	 * When generated, this attribute will enable source code highlighting in debugger
>+	 * (.class file is then bigger).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.debug.lineNumber"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"generate"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_LINE_NUMBER_ATTR = PLUGIN_ID + ".compiler.debug.lineNumber"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Generating Source Debug Attribute.
>+ * When generated, this attribute will enable the debugger to present the
>+	 * corresponding source code.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.debug.sourceFile"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"generate"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_SOURCE_FILE_ATTR = PLUGIN_ID + ".compiler.debug.sourceFile"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Preserving Unused Local Variables.
>+ * Unless requested to preserve unused local variables (that is, never read), the
>+	 * compiler will optimize them out, potentially altering debugging.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.unusedLocal"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "preserve", "optimize out" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"preserve"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_CODEGEN_UNUSED_LOCAL = PLUGIN_ID + ".compiler.codegen.unusedLocal"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Defining Target Java Platform.
>+ * For binary compatibility reason, .class files can be tagged to with certain VM versions and later.
>+	 * Note that <code>"1.4"</code> target requires to toggle compliance mode to <code>"1.4"</code>, <code>"1.5"</code> target requires
>+	 * to toggle compliance mode to <code>"1.5"</code>, <code>"1.6"</code> target requires to toggle compliance mode to <code>"1.6"</code> and
>+	 * <code>"1.7"</code> target requires to toggle compliance mode to <code>"1.7"</code>.
>+	 * <code>"cldc1.1"</code> requires the source version to be <code>"1.3"</code> and the compliance version to be <code>"1.4"</code> or lower.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.targetPlatform"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "cldc1.1" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"1.2"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_CODEGEN_TARGET_PLATFORM = PLUGIN_ID + ".compiler.codegen.targetPlatform"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_CODEGEN_TARGET_PLATFORM}).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_CODEGEN_INLINE_JSR_BYTECODE = PLUGIN_ID + ".compiler.codegen.inlineJsrBytecode"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.doc.comment.support"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_DOC_COMMENT_SUPPORT = PLUGIN_ID + ".compiler.doc.comment.support"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @deprecated - discontinued since turning off would violate language specs
>+	 * @deprecated Discontinued since turning off would violate language specs.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String COMPILER_PB_UNREACHABLE_CODE = PLUGIN_ID + ".compiler.problem.unreachableCode"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @deprecated - discontinued since turning off would violate language specs
>+	 * @deprecated Discontinued since turning off would violate language specs.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String COMPILER_PB_INVALID_IMPORT = PLUGIN_ID + ".compiler.problem.invalidImport"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_OVERRIDING_PACKAGE_DEFAULT_METHOD = PLUGIN_ID + ".compiler.problem.overridingPackageDefaultMethod"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME = PLUGIN_ID + ".compiler.problem.methodWithConstructorName"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Deprecation.
>+ * When enabled, the compiler will signal use of deprecated API either as an
>+	 * error or a warning.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_DEPRECATION = PLUGIN_ID + ".compiler.problem.deprecation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_DEPRECATION}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE = PLUGIN_ID + ".compiler.problem.deprecationInDeprecatedCode"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_DEPRECATION}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecationInNonDeprecatedCode"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_DEPRECATION_IN_NON_DEPRECATED_CODE = PLUGIN_ID + ".compiler.problem.deprecationInNonDeprecatedCode"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_DEPRECATION}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD = "org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Hidden Catch Block.
>+ * 
>+	 * Locally to a try statement, some catch blocks may hide others. For example,
>+	 * <pre>
>+	 * try { throw new java.io.CharConversionException();
>+	 * } catch (java.io.CharConversionException e) {
>+	 * } catch (java.io.IOException e) {}.
>+	 * </pre>
>+	 * When enabling this option, the compiler will issue an error or a warning for hidden
>+	 * catch blocks corresponding to checked exceptions.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_HIDDEN_CATCH_BLOCK = PLUGIN_ID + ".compiler.problem.hiddenCatchBlock"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unused Local.
>+ * When enabled, the compiler will issue an error or a warning for unused local
>+	 * variables (that is, variables never read from).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLocal"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_LOCAL = PLUGIN_ID + ".compiler.problem.unusedLocal"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unused Parameter.
>+ * When enabled, the compiler will issue an error or a warning for unused method
>+	 * parameters (that is, parameters never read from).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameter"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedParameter"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_UNUSED_PARAMETER}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_IMPLEMENTING_ABSTRACT = PLUGIN_ID + ".compiler.problem.unusedParameterWhenImplementingAbstract"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_UNUSED_PARAMETER}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_OVERRIDING_CONCRETE = PLUGIN_ID + ".compiler.problem.unusedParameterWhenOverridingConcrete"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Consider Reference in Doc Comment for Unused Parameter Check.
>+ * When enabled, the compiler will consider doc comment references to parameters (i.e. <code>@param</code> 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}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.3
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE = PLUGIN_ID + ".compiler.problem.unusedParameterIncludeDocCommentReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unused Import.
>+ * When enabled, the compiler will issue an error or a warning for unused import
>+	 * reference.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedImport"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_IMPORT = PLUGIN_ID + ".compiler.problem.unusedImport"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 <code>"1.7"</code>, this situation would automatically result
>+	 * in an error. From Java7 on, unused type arguments are being tolerated, and optionally warned against.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_TYPE_ARGUMENTS_FOR_METHOD_INVOCATION = PLUGIN_ID + ".compiler.problem.unusedTypeArgumentsForMethodInvocation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_SYNTHETIC_ACCESS_EMULATION = PLUGIN_ID + ".compiler.problem.syntheticAccessEmulation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 <code>//$NON-NLS-&lt;n&gt;$</code>).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_NON_NLS_STRING_LITERAL = PLUGIN_ID + ".compiler.problem.nonExternalizedStringLiteral"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Usage of <code>'assert'</code> Identifier.
>+ * When enabled, the compiler will issue an error or a warning whenever <code>'assert'</code> is
>+	 * used as an identifier (reserved keyword in 1.4).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.assertIdentifier"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_ASSERT_IDENTIFIER = PLUGIN_ID + ".compiler.problem.assertIdentifier"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Usage of <code>'enum'</code> Identifier.
>+ * When enabled, the compiler will issue an error or a warning whenever <code>'enum'</code> is
>+	 * used as an identifier (reserved keyword in 1.5).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.enumIdentifier"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_ENUM_IDENTIFIER = PLUGIN_ID + ".compiler.problem.enumIdentifier"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_STATIC_ACCESS_RECEIVER = PLUGIN_ID + ".compiler.problem.staticAccessReceiver"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INDIRECT_STATIC_ACCESS = PLUGIN_ID + ".compiler.problem.indirectStaticAccess"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Assignment with no Effect.
>+ * When enabled, the compiler will issue an error or a warning whenever an assignment
>+	 * has no effect (e.g <code>'x = x'</code>).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_NO_EFFECT_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.noEffectAssignment"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 <code>Object</code> method. Until this conflict
>+	 * is resolved, such an interface cannot be implemented, For example,
>+	 * <pre>
>+	 * interface I {
>+	 * int clone();
>+	 * }
>+	 * </pre>
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INCOMPATIBLE_NON_INHERITED_INTERFACE_METHOD = PLUGIN_ID + ".compiler.problem.incompatibleNonInheritedInterfaceMethod"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_PRIVATE_MEMBER = PLUGIN_ID + ".compiler.problem.unusedPrivateMember"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.localVariableHiding"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_LOCAL_VARIABLE_HIDING = PLUGIN_ID + ".compiler.problem.localVariableHiding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_LOCAL_VARIABLE_HIDING}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD = PLUGIN_ID + ".compiler.problem.specialParameterHidingField"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fieldHiding"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_FIELD_HIDING = PLUGIN_ID + ".compiler.problem.fieldHiding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_TYPE_PARAMETER_HIDING = PLUGIN_ID + ".compiler.problem.typeParameterHiding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.possibleAccidentalBooleanAssignment"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fallthroughCase"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_FALLTHROUGH_CASE = PLUGIN_ID + ".compiler.problem.fallthroughCase"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.emptyStatement"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_EMPTY_STATEMENT = PLUGIN_ID + ".compiler.problem.emptyStatement"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @since 3.0
>+ * Compiler option ID.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl> 
>+ * @since 3.0
>+ * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION = PLUGIN_ID + ".compiler.problem.booleanMethodThrowingException"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unnecessary Type Check.
>+ * When enabled, the compiler will issue an error or a warning when a cast or an <code>instanceof</code> operation
>+	 * is unnecessary.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNNECESSARY_TYPE_CHECK = PLUGIN_ID + ".compiler.problem.unnecessaryTypeCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unnecessary Else.
>+ * When enabled, the compiler will issue an error or a warning when a statement is unnecessarily
>+	 * nested within an <code>else</code> clause (in situation where then clause is not completing normally).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNNECESSARY_ELSE = PLUGIN_ID + ".compiler.problem.unnecessaryElse"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNDOCUMENTED_EMPTY_BLOCK = PLUGIN_ID + ".compiler.problem.undocumentedEmptyBlock"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING = PLUGIN_ID + ".compiler.problem.finallyBlockNotCompletingNormally"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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
>+	 * {@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. 
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownException"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Consider Reference in Doc Comment for Unused Declared Thrown Exception Check.
>+ * When enabled, the compiler will consider doc comment references to exceptions (i.e. <code>@throws</code> 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}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 
>+	 * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeUncheckedExceptions"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_UNCHECKED_EXCEPTIONS = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionIncludeUncheckedExceptions"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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. <code>'x'</code> should rather be written <code>'this.x'</code>.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNQUALIFIED_FIELD_ACCESS = PLUGIN_ID + ".compiler.problem.unqualifiedFieldAccess"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @deprecated - got renamed into {@link #COMPILER_PB_UNCHECKED_TYPE_OPERATION}
>+ * @deprecated Use {@link #COMPILER_PB_UNCHECKED_TYPE_OPERATION} instead.
> 	 * @since 3.1
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String COMPILER_PB_UNSAFE_TYPE_OPERATION = PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 <code>#foo(X&lt;String&gt;)</code> with arguments <code>(X)</code>).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNCHECKED_TYPE_OPERATION = PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.rawTypeReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_RAW_TYPE_REFERENCE = PLUGIN_ID + ".compiler.problem.rawTypeReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finalParameterBound"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_FINAL_PARAMETER_BOUND = PLUGIN_ID + ".compiler.problem.finalParameterBound"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 <code>serialVersionUID</code> field. This field must be declared as static final and be of type <code>long</code>.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSerialVersion"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_SERIAL_VERSION = PLUGIN_ID + ".compiler.problem.missingSerialVersion"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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. <code>Class.getMethod(String name, Class ... args )</code>
>+	 * invoked with arguments <code>("foo", null)</code>).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST = PLUGIN_ID + ".compiler.problem.varargsArgumentNeedCast"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Boxing/Unboxing Conversion.
>+ * When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing
>+	 * conversion is performed.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.autoboxing"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_AUTOBOXING = PLUGIN_ID + ".compiler.problem.autoboxing"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_ANNOTATION_SUPER_INTERFACE = PLUGIN_ID + ".compiler.problem.annotationSuperInterface"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Missing <code>@Override</code> 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 <code>@Override</code> annotation.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Missing <code>@Deprecated</code> Annotation.
>+ * When enabled, the compiler will issue an error or a warning whenever encountering a declaration
>+	 * carrying a <code>@deprecated</code> doc tag but having no corresponding <code>@Deprecated</code> annotation.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_DEPRECATED_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingDeprecatedAnnotation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INCOMPLETE_ENUM_SWITCH = PLUGIN_ID + ".compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @since 3.1
>-	 * @deprecated use {@link #COMPILER_PB_NULL_REFERENCE} instead
>+ * @since 3.1
>+	 * @deprecated Use {@link #COMPILER_PB_NULL_REFERENCE} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String COMPILER_PB_INCONSISTENT_NULL_CHECK = PLUGIN_ID + ".compiler.problem.inconsistentNullCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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:
>+	 * <code>LABEL: { break; }</code>
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLabel"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_LABEL = PLUGIN_ID + ".compiler.problem.unusedLabel"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INVALID_JAVADOC = PLUGIN_ID + ".compiler.problem.invalidJavadoc"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Invalid Javadoc Tags.
>+ * When enabled, the compiler will signal unbound or unexpected reference tags in Javadoc.
>+	 * A <code>@throws</code> 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}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @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}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__DEPRECATED_REF = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsDeprecatedRef"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__NOT_VISIBLE_REF = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsNotVisibleRef"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Visibility Level For Invalid Javadoc Tags.
>+ * Set the minimum visibility level for Javadoc tag problems. Below this level problems will be ignored.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "public", "protected", "default", "private" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"public"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsVisibility"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_INVALID_JAVADOC}.
>+	 * This option is NOT dependent from the Report errors in tags option.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "return_tag", "all_tags", "no_tag" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"return_tag"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION = PLUGIN_ID + ".compiler.problem.missingJavadocTagDescription"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>-	 * @since 3.4
>-	 */
>-	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_NO_TAG = CompilerOptions.NO_TAG;
>-	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>-	 * @since 3.4
>-	 */
>-	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG = CompilerOptions.RETURN_TAG;
>-	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>-	 * @since 3.4
>-	 */
>-	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_TAGS = CompilerOptions.ALL_TAGS;
>-	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS = PLUGIN_ID + ".compiler.problem.missingJavadocTags"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Visibility Level For Missing Javadoc Tags.
>+ * Set the minimum visibility level for Javadoc missing tag problems. Below this level problems will be ignored.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "public", "protected", "default", "private" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"public"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocTagsVisibility"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Missing Javadoc Tags on Overriding Methods.
>+ * Specify whether the compiler will verify overriding methods in order to report Javadoc missing tag problems.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING = PLUGIN_ID + ".compiler.problem.missingJavadocTagsOverriding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 {@link #COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY}.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS = PLUGIN_ID + ".compiler.problem.missingJavadocComments"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Visibility Level For Missing Javadoc Comments.
>+ * Set the minimum visibility level for missing Javadoc problems. Below this level problems will be ignored.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "public", "protected", "default", "private" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"public"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsVisibility"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Missing Javadoc Comments on Overriding Methods.
>+ * Specify whether the compiler will verify overriding methods in order to report missing Javadoc comment problems.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsOverriding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Usage of <code>char[]</code> Expressions in String Concatenations.
>+ * When enabled, the compiler will issue an error or a warning whenever a <code>char[]</code> expression
>+	 * is used in String concatenations (for example, <code>"hello" + new char[]{'w','o','r','l','d'}</code>).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION = PLUGIN_ID + ".compiler.problem.noImplicitStringConversion"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Maximum Number of Problems Reported per Compilation Unit.
>+ * Specify the maximum number of problems reported on each compilation unit.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.maxProblemPerUnit"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>"&lt;n&gt;"</code> where <code>&lt;n&gt;</code> is zero or a positive integer (if zero then all problems are reported).</dd>
>+	 * <dt>Default:</dt><dd><code>"100"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_MAX_PER_UNIT = PLUGIN_ID + ".compiler.maxProblemPerUnit"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Treating Optional Error as Fatal.
>+ * When enabled, optional errors (i.e. optional problems which severity is set to <code>"error"</code>) 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fatalOptionalError"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_FATAL_OPTIONAL_ERROR = PLUGIN_ID + ".compiler.problem.fatalOptionalError"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Parameter Assignment.
>+ * When enabled, the compiler will issue an error or a warning if a parameter is
>+	 * assigned to.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.parameterAssignment"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_PARAMETER_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.parameterAssignment"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Setting Source Compatibility Mode.
>+ * Specify whether which source level compatibility is used. From 1.4 on, <code>'assert'</code> is a keyword
>+	 * reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM
>+	 * level should be set to <code>"1.4"</code> and the compliance mode should be <code>"1.4"</code>.
>+	 * 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 <code>"1.5"</code>
>+	 * and the compliance mode should be <code>"1.5"</code>.
>+	 * Source level 1.6 is necessary to enable the computation of stack map tables. Once toggled, the target
>+	 * VM level should be set to <code>"1.6"</code> and the compliance mode should be <code>"1.6"</code>.
>+	 * Once the source level 1.7 is toggled, the target VM level should be set to <code>"1.7"</code> and the compliance mode
>+	 * should be <code>"1.7"</code>.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.source"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "1.3", "1.4", "1.5", "1.6", "1.7" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"1.3"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_SOURCE = PLUGIN_ID + ".compiler.source"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Setting Compliance Level.
>+ * Select the compliance level for the compiler. In <code>"1.3"</code> mode, source and target settings
>+	 * should not go beyond <code>"1.3"</code> level.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.compliance"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "1.3", "1.4", "1.5", "1.6", "1.7" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"1.4"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_COMPLIANCE = PLUGIN_ID + ".compiler.compliance"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 <code>"NORMAL"</code>.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.taskPriorities"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;priority&gt;[,&lt;priority&gt;]*" }</code> where <code>&lt;priority&gt;</code> is one of <code>"HIGH"</code>, <code>"NORMAL"</code> or <code>"LOW"</code></dd>
>+	 * <dt>Default:</dt><dd><code>"NORMAL,HIGH,NORMAL"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_TASK_PRIORITIES = PLUGIN_ID + ".compiler.taskPriorities"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value for COMPILER_TASK_PRIORITIES.
>-	 * @see #getDefaultOptions()
>-	 * @since 2.1
>-	 */
>-	public static final String COMPILER_TASK_PRIORITY_HIGH = "HIGH"; //$NON-NLS-1$
>-	/**
>-	 * Possible configurable option value for COMPILER_TASK_PRIORITIES.
>-	 * @see #getDefaultOptions()
>-	 * @since 2.1
>-	 */
>-	public static final String COMPILER_TASK_PRIORITY_LOW = "LOW"; //$NON-NLS-1$
>-	/**
>-	 * Possible configurable option value for COMPILER_TASK_PRIORITIES.
>-	 * @see #getDefaultOptions()
>-	 * @since 2.1
>-	 */
>-	public static final String COMPILER_TASK_PRIORITY_NORMAL = "NORMAL"; //$NON-NLS-1$
>-	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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 (<code>"fooToDo"</code> will not be recognized as a task for tag <code>"ToDo"</code>, but <code>"foo#ToDo"</code>
>+	 * will be detected for either tag <code>"ToDo"</code> or <code>"#ToDo"</code>). Respectively, a tag ending with a letter or digit cannot be followed
>+	 * by a letter or digit to be recognized (<code>"ToDofoo"</code> will not be recognized as a task for tag <code>"ToDo"</code>, but <code>"ToDo:foo"</code> will
>+	 * be detected either for tag <code>"ToDo"</code> or <code>"ToDo:"</code>).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.taskTags"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;tag&gt;[,&lt;tag&gt;]*" }</code> where <code>&lt;tag&gt;</code> is a String without any wild-card or leading/trailing spaces</dd>
>+	 * <dt>Default:</dt><dd><code>"TODO,FIXME,XXX"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_TASK_TAGS = PLUGIN_ID + ".compiler.taskTags"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Determining whether task tags are case-sensitive.
>+ * When enabled, task tags are considered in a case-sensitive way.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.taskCaseSensitive"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_TASK_CASE_SENSITIVE = PLUGIN_ID + ".compiler.taskCaseSensitive"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.forbiddenReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"error"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_FORBIDDEN_REFERENCE = PLUGIN_ID + ".compiler.problem.forbiddenReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.discouragedReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_DISCOURAGED_REFERENCE = PLUGIN_ID + ".compiler.problem.discouragedReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Determining Effect of <code>@SuppressWarnings</code>.
>+ * When enabled, the <code>@SuppressWarnings</code> annotation can be used to suppress some compiler warnings.
>+	 * When disabled, all <code>@SupressWarnings</code> annotations are ignored; i.e., warnings are reported.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.suppressWarnings"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_SUPPRESS_WARNINGS = PLUGIN_ID + ".compiler.problem.suppressWarnings"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unhandled Warning Token for <code>@SuppressWarnings</code>.
>+ * When enabled, the compiler will issue an error or a warning when encountering a token
>+	 * it cannot handle inside a <code>@SuppressWarnings</code> annotation.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNHANDLED_WARNING_TOKEN = PLUGIN_ID + ".compiler.problem.unhandledWarningToken"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: Reporting Unnecessary <code>@SuppressWarnings</code>.
>+ * When enabled, the compiler will issue an error or a warning when encountering <code>@SuppressWarnings</code> annotation 
>+	 * for which no corresponding warning got detected in the code. This diagnostic is provided to help developers to get
>+	 * rid of transient <code>@SuppressWarnings</code> no longer needed. Note that <code>@SuppressWarnings("all")</code> is still 
>+	 * silencing the warning for unnecessary <code>@SuppressWarnings</code>, as it is the master switch to silence ALL warnings.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_UNUSED_WARNING_TOKEN = PLUGIN_ID + ".compiler.problem.unusedWarningToken"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.nullReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentialNullReference"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.3
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_POTENTIAL_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.potentialNullReference"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.3
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_REDUNDANT_NULL_CHECK = PLUGIN_ID + ".compiler.problem.redundantNullCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.3
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_OVERRIDING_METHOD_WITHOUT_SUPER_INVOCATION = PLUGIN_ID + ".compiler.problem.overridingMethodWithoutSuperInvocation"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Compiler option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.4
>+	 * @category CompilerOptionID
> 	 */
> 	public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE = PLUGIN_ID + ".compiler.problem.redundantSuperinterface"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.computeJavaBuildOrder"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "compute", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_JAVA_BUILD_ORDER = PLUGIN_ID + ".computeJavaBuildOrder"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: Specifying Filters for Resource Copying Control.
>+ * Allow to specify some filters to control the resource copy process.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;name&gt;[,&lt;name&gt;]* }</code> where <code>&lt;name&gt;</code> is a file name pattern (* and ? wild-cards allowed)
>+	 * or the name of a folder which ends with <code>'/'</code></dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_JAVA_BUILD_RESOURCE_COPY_FILTER = PLUGIN_ID + ".builder.resourceCopyExclusionFilter"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.duplicateResourceTask"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_JAVA_BUILD_DUPLICATE_RESOURCE = PLUGIN_ID + ".builder.duplicateResourceTask"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: Cleaning Output Folder(s).
>+ * Indicate whether the JavaBuilder is allowed to clean the output folders
>+	 * when performing full build operations.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.cleanOutputFolder"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "clean", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"clean"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER = PLUGIN_ID + ".builder.cleanOutputFolder"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER = PLUGIN_ID + ".builder.recreateModifiedClassFileInOutputFolder"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.incompleteClasspath"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning"}</code></dd>
>+	 * <dt>Default:</dt><dd><code>"error"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_INCOMPLETE_CLASSPATH = PLUGIN_ID + ".incompleteClasspath"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: Reporting Classpath Cycle.
>+ * Indicate the severity of the problem reported when a project is involved in a cycle.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.circularClasspath"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"error"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_CIRCULAR_CLASSPATH = PLUGIN_ID + ".circularClasspath"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.incompatibleJDKLevel"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
>+ * </dl>
> 	 * @since 3.0
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_INCOMPATIBLE_JDK_LEVEL = PLUGIN_ID + ".incompatibleJDKLevel"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: Abort if Invalid Classpath.
>+ * Allow to toggle the builder to abort if the classpath is invalid.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.invalidClasspath"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "abort", "ignore" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"abort"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_JAVA_BUILD_INVALID_CLASSPATH = PLUGIN_ID + ".builder.invalidClasspath"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: Default Source Encoding Format.
>+ * Get the default encoding format of source files. This value is
>+	 * immutable and preset to the result of <code>ResourcesPlugin.getEncoding()</code>.
>+	 * It is offered as a convenience shortcut only.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.encoding"</code></dd>
>+	 * <dt>value:</dt><dd><code>&lt;immutable, platform default value&gt;</code></dd>
>+	 * </dl>
> 	 * @since 2.0
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_ENCODING = PLUGIN_ID + ".encoding"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: Enabling Usage of Classpath Exclusion Patterns.
>+ * When disabled, no entry on a project classpath can be associated with
>+	 * an exclusion pattern.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.exclusionPatterns"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS = PLUGIN_ID + ".classpath.exclusionPatterns"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Core option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.multipleOutputLocations"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CoreOptionID
> 	 */
> 	public static final String CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS = PLUGIN_ID + ".classpath.multipleOutputLocations"; //$NON-NLS-1$
> 	/**
>-	 * Default task tag
>-	 * @deprecated Use {@link #DEFAULT_TASK_TAGS} instead
>-	 * @since 2.1
>-	 */
>-	public static final String DEFAULT_TASK_TAG = "TODO"; //$NON-NLS-1$
>-	/**
>-	 * Default task priority
>-	 * @deprecated Use {@link #DEFAULT_TASK_PRIORITIES} instead
>-	 * @since 2.1
>-	 */
>-	public static final String DEFAULT_TASK_PRIORITY = "NORMAL"; //$NON-NLS-1$
>-	/**
>-	 * Default task tag
>-	 * @since 3.0
>-	 */
>-	public static final String DEFAULT_TASK_TAGS = "TODO,FIXME,XXX"; //$NON-NLS-1$
>-	/**
>-	 * Default task priority
>-	 * @since 3.0
>+ * Core option ID: 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 <code>0</code>, the parameter names are not fetched and the raw names are returned.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>"&lt;n&gt;"</code>, where <code>n</code> is an integer greater than or equal to <code>0</code></dd>
>+	 * <dt>Default:</dt><dd><code>"50"</code></dd>
>+ * </dl>
>+	 * @since 3.2
>+	 * @category CoreOptionID
> 	 */
>-	public static final String DEFAULT_TASK_PRIORITIES = "NORMAL,HIGH,NORMAL"; //$NON-NLS-1$
>+	public static final String TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC = PLUGIN_ID + ".timeoutForParameterNameFromAttachedJavadoc"; //$NON-NLS-1$
>+
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @since 2.0
>+ * @since 2.0
> 	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION},
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_BLOCK} ,
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION},
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION},
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_SWITCH},
>-	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION} instead
>+	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_NEWLINE_OPENING_BRACE = PLUGIN_ID + ".formatter.newline.openingBrace"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @since 2.0
>+ * @since 2.0
> 	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT},
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT},
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT},
> 	 * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_NEWLINE_CONTROL = PLUGIN_ID + ".formatter.newline.controlStatement"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_COMPACT_ELSE_IF} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_COMPACT_ELSE_IF} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_NEWLINE_ELSE_IF = PLUGIN_ID + ".formatter.newline.elseIf"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_NEWLINE_EMPTY_BLOCK = PLUGIN_ID + ".formatter.newline.emptyBlock"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_CLEAR_BLANK_LINES = PLUGIN_ID + ".formatter.newline.clearAll"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
> 	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_LINE_SPLIT} instead
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_LINE_SPLIT = PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_COMPACT_ASSIGNMENT = PLUGIN_ID + ".formatter.style.assignment"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_CHAR}} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_CHAR} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_TAB_CHAR = PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
> 	 * @since 2.0
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_SIZE} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_SIZE} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_TAB_SIZE = PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID
>-	 * @see #getDefaultOptions()
> 	 * @since 2.1
>-	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST} instead
>+	 * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST} instead.
>+	 * @category DeprecatedOptionID
> 	 */
> 	public static final String FORMATTER_SPACE_CASTEXPRESSION = PLUGIN_ID + ".formatter.space.castexpression"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: 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).
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.visibilityCheck"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_VISIBILITY_CHECK = PLUGIN_ID + ".codeComplete.visibilityCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Activate Deprecation Sensitive Completion.
>+ * When enabled, completion doesn't propose deprecated members and types.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.deprecationCheck"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_DEPRECATION_CHECK = PLUGIN_ID + ".codeComplete.deprecationCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Activate Camel Case Sensitive Completion.
>+ * When enabled, completion shows proposals whose name match the CamelCase
>+	 * pattern.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.camelCaseMatch"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.2
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_CAMEL_CASE_MATCH = PLUGIN_ID + ".codeComplete.camelCaseMatch"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Automatic Qualification of Implicit Members.
>+ * When active, completion automatically qualifies completion on implicit
>+	 * field references and message expressions.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.forceImplicitQualification"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 2.0
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_IMPLICIT_QUALIFICATION = PLUGIN_ID + ".codeComplete.forceImplicitQualification"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Define the Prefixes for Field Name.
>+ * When the prefixes is non empty, completion for field name will begin with
>+	 * one of the proposed prefixes.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.fieldPrefixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;prefix&gt;[,&lt;prefix&gt;]*" }</code> where <code>&lt;prefix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.fieldPrefixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;prefix&gt;[,&lt;prefix&gt;]*" }</code> where <code>&lt;prefix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_STATIC_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.localPrefixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;prefix&gt;[,&lt;prefix&gt;]*" }</code> where <code>&lt;prefix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_LOCAL_PREFIXES = PLUGIN_ID + ".codeComplete.localPrefixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Define the Prefixes for Argument Name.
>+ * When the prefixes is non empty, completion for argument name will begin with
>+	 * one of the proposed prefixes.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.argumentPrefixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;prefix&gt;[,&lt;prefix&gt;]*" }</code> where <code>&lt;prefix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_ARGUMENT_PREFIXES = PLUGIN_ID + ".codeComplete.argumentPrefixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Define the Suffixes for Field Name.
>+ * When the suffixes is non empty, completion for field name will end with
>+	 * one of the proposed suffixes.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.fieldSuffixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;suffix&gt;[,&lt;suffix&gt;]*" }</code> where <code>&lt;suffix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.fieldSuffixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;suffix&gt;[,&lt;suffix&gt;]*" }</code>< where <code>&lt;suffix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_STATIC_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: 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.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.localSuffixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;suffix&gt;[,&lt;suffix&gt;]*" }</code> where <code>&lt;suffix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_LOCAL_SUFFIXES = PLUGIN_ID + ".codeComplete.localSuffixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Define the Suffixes for Argument Name.
>+ * When the suffixes is non empty, completion for argument name will end with
>+	 * one of the proposed suffixes.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.argumentSuffixes"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "&lt;suffix&gt;[,&lt;suffix&gt;]*" }</code> where <code>&lt;suffix&gt;</code> is a String without any wild-card</dd>
>+	 * <dt>Default:</dt><dd><code>""</code></dd>
>+ * </dl>
> 	 * @since 2.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_ARGUMENT_SUFFIXES = PLUGIN_ID + ".codeComplete.argumentSuffixes"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Activate Forbidden Reference Sensitive Completion.
>+ * When enabled, completion doesn't propose elements which match a
>+ 	 * forbidden reference rule.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_FORBIDDEN_REFERENCE_CHECK= PLUGIN_ID + ".codeComplete.forbiddenReferenceCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Activate Discouraged Reference Sensitive Completion.
>+ * When enabled, completion doesn't propose elements which match a
>+ 	 * discouraged reference rule.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
>+ * </dl>
> 	 * @since 3.1
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_DISCOURAGED_REFERENCE_CHECK= PLUGIN_ID + ".codeComplete.discouragedReferenceCheck"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>+ * Code assist option ID: Activate Suggestion of Static Import.
>+ * When enabled, completion proposals can contain static import
>+	 * pattern.
>+ * <dl>
>+	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.suggestStaticImports"</code></dd>
>+	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
>+	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
>+ * </dl>
> 	 * @since 3.3
>+	 * @category CodeAssistOptionID
> 	 */
> 	public static final String CODEASSIST_SUGGEST_STATIC_IMPORTS= PLUGIN_ID + ".codeComplete.suggestStaticImports"; //$NON-NLS-1$
>+	// end configurable option IDs }
>+	// Begin configurable option values {
> 	/**
>-	 * Possible configurable option ID.
>-	 * @see #getDefaultOptions()
>-	 * @since 3.2
>+	 * @deprecated Use {@link #DEFAULT_TASK_TAGS} instead.
>+	 * @since 2.1
>+	 * @category DeprecatedOptionValue
>+	 */
>+	public static final String DEFAULT_TASK_TAG = "TODO"; //$NON-NLS-1$
>+	/**
>+	 * @deprecated Use {@link #DEFAULT_TASK_PRIORITIES} instead.
>+	 * @since 2.1
>+	 * @category DeprecatedOptionValue
>+	 */
>+	public static final String DEFAULT_TASK_PRIORITY = "NORMAL"; //$NON-NLS-1$
>+	/**
>+	 * Configurable option value: {@value}.
>+	 * @since 3.0
>+	 * @category OptionValue
>+	 */
>+	public static final String DEFAULT_TASK_TAGS = "TODO,FIXME,XXX"; //$NON-NLS-1$
>+	/**
>+	 * Configurable option value: {@value}.
>+	 * @since 3.0
>+	 * @category OptionValue
> 	 */
>-	public static final String TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC = PLUGIN_ID + ".timeoutForParameterNameFromAttachedJavadoc"; //$NON-NLS-1$
>-
>+	public static final String DEFAULT_TASK_PRIORITIES = "NORMAL,HIGH,NORMAL"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String GENERATE = "generate"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String DO_NOT_GENERATE = "do not generate"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String PRESERVE = "preserve"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String OPTIMIZE_OUT = "optimize out"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value for {@link #COMPILER_TASK_PRIORITIES}: {@value}.
>+	 * @since 2.1
>+	 * @category OptionValue
>+	 */
>+	public static final String COMPILER_TASK_PRIORITY_HIGH = "HIGH"; //$NON-NLS-1$
>+	/**
>+	 * Configurable option value for {@link #COMPILER_TASK_PRIORITIES}: {@value}.
>+	 * @since 2.1
>+	 * @category OptionValue
>+	 */
>+	public static final String COMPILER_TASK_PRIORITY_LOW = "LOW"; //$NON-NLS-1$
>+	/**
>+	 * Configurable option value for {@link #COMPILER_TASK_PRIORITIES}: {@value}.
>+	 * @since 2.1
>+	 * @category OptionValue
>+	 */
>+	public static final String COMPILER_TASK_PRIORITY_NORMAL = "NORMAL"; //$NON-NLS-1$
>+	/**
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_1 = "1.1"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_2 = "1.2"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_3 = "1.3"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_4 = "1.4"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.0
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_5 = "1.5"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.2
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_6 = "1.6"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.3
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_1_7 = "1.7"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.4
>+	 * @category OptionValue
> 	 */
> 	public static final String VERSION_CLDC_1_1 = "cldc1.1"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String ABORT = "abort"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String ERROR = "error"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String WARNING = "warning"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String IGNORE = "ignore"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
>+	 * @category OptionValue
> 	 */
> 	public static final String COMPUTE = "compute"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String INSERT = "insert"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String DO_NOT_INSERT = "do not insert"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String PRESERVE_ONE = "preserve one"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String CLEAR_ALL = "clear all"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String NORMAL = "normal"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String COMPACT = "compact"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String TAB = "tab"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String SPACE = "space"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String ENABLED = "enabled"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.0
>+	 * @category OptionValue
> 	 */
> 	public static final String DISABLED = "disabled"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 2.1
>+	 * @category OptionValue
> 	 */
> 	public static final String CLEAN = "clean"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.0
>+	 * @category OptionValue
> 	 */
> 	public static final String PUBLIC = "public"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.0
>+	 * @category OptionValue
> 	 */
> 	public static final String PROTECTED = "protected"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.0
>+	 * @category OptionValue
> 	 */
> 	public static final String DEFAULT = "default"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.0
>+	 * @category OptionValue
> 	 */
> 	public static final String PRIVATE = "private"; //$NON-NLS-1$
> 	/**
>-	 * Possible configurable option value.
>-	 * @see #getDefaultOptions()
>+	 * Configurable option value: {@value}.
> 	 * @since 3.1
>+	 * @category OptionValue
> 	 */
> 	public static final String NEVER = "never"; //$NON-NLS-1$
>+	/**
>+	 * Configurable option value: {@value}.
>+	 * @since 3.4
>+	 * @category OptionValue
>+	 */
>+	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_NO_TAG = CompilerOptions.NO_TAG;
>+	/**
>+	 * Configurable option value: {@value}.
>+	 * @since 3.4
>+	 * @category OptionValue
>+	 */
>+	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG = CompilerOptions.RETURN_TAG;
>+	/**
>+	 * Configurable option value: {@value}.
>+	 * @since 3.4
>+	 * @category OptionValue
>+	 */
>+	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_TAGS = CompilerOptions.ALL_TAGS;
>+	// end configurable option values }
> 
> 	/**
> 	 * Value of the content-type for Java source files. Use this value to retrieve the Java content type
>@@ -1957,981 +2850,15 @@
> 	 * These options allow to configure the behaviour of the underlying components.
> 	 * The client may safely use the result as a template that they can modify and
> 	 * then pass to <code>setOptions</code>.
>-	 *
>-	 * 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.
>-	 * <pre>
>-	 * 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-&lt;n&gt;$).
>-	 * - 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&lt;String&gt;) 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:	"&lt;n&gt;" where &lt;n&gt; 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: { "&lt;tag&gt;[,&lt;tag&gt;]*" } where &lt;tag&gt; 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: { "&lt;priority&gt;[,&lt;priority&gt;]*" } where &lt;priority&gt; 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 <code>@SuppressWarnings("all")</code> is still 
>-	 * silencing the warning for unnecessary <code>@SuppressWarnings</code>, 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: { "&lt;name&gt;[,&lt;name&gt;]* } where &lt;name&gt; 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: &lt;immutable, platform default value&gt;
>-	 *
>-	 * 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:	"&lt;n&gt;", 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:	"&lt;n&gt;", 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:	"&lt;n&gt;", 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: { "&lt;prefix&gt;[,&lt;prefix&gt;]*" } where &lt;prefix&gt; 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: { "&lt;prefix&gt;[,&lt;prefix&gt;]*" } where &lt;prefix&gt; 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: { "&lt;prefix&gt;[,&lt;prefix&gt;]*" } where &lt;prefix&gt; 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: { "&lt;prefix&gt;[,&lt;prefix&gt;]*" } where &lt;prefix&gt; 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: { "&lt;suffix&gt;[,&lt;suffix&gt;]*" } where &lt;suffix&gt; 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: { "&lt;suffix&gt;[,&lt;suffix&gt;]*" } where &lt;suffix&gt; 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: { "&lt;suffix&gt;[,&lt;suffix&gt;]*" } where &lt;suffix&gt; 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: { "&lt;suffix&gt;[,&lt;suffix&gt;]*" } where &lt;suffix&gt; 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"
>-	 * </pre>
>+	 * 
>+	 * 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 +3103,12 @@
> 	 * Helper method for returning one option value only. Equivalent to <code>(String)JavaCore.getOptions().get(optionName)</code>
> 	 * Note that it may answer <code>null</code> if this option does not exist.
> 	 * 
>-	 * For a complete description of the configurable options, see <code>getDefaultOptions</code>.
>-	 * 
>+	 * 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.
> 	 *
> 	 * @param optionName the name of an option
> 	 * @return the String value of a given option
>@@ -3192,7 +3123,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 <code>getDefaultOptions</code>.
>+	 * 
>+	 * 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 +4754,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:
> 	 * <ul>
>@@ -4882,9 +4819,12 @@
> 	 * included in the given table are remembered; all previous option settings
> 	 * are forgotten, including ones not explicitly mentioned.
> 	 * 
>-	 * For a complete description of the configurable options, see
>-	 * <code>getDefaultOptions</code>.
>-	 * 
>+	 * 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.
> 	 *
> 	 * @param newOptions
> 	 * the new options (key type: <code>String</code>; value type:
>@@ -4926,4 +4866,4 @@
> 		super.start(context);
> 		JavaModelManager.getJavaModelManager().startup();
> 	}
>-}
>\ No newline at end of file
>+}

Actions: View | Diff

Attachments on bug 202490: 87857 | 88007 | 88294 | 88382